• Bool
• Bool.parser_for : _
• Bool.encoder_for : _
• 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.parser_for : _
• Box.encoder_for : _
• Box.box : item -> Box(item)
• Box.unbox : Box(item) -> item
• Crypto
• 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
• Dict.parser_for : _
• Dict.encoder_for : _
• 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.to_inspect : Dict(k, v) -> Str
• 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.subscript : 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.iter : Dict(k, v) -> Iter((k, v))
• Dict.iter_rev : Dict(k, v) -> Iter((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.from_iter : Iter((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.fold_until : Dict(k, v), state, (state, k, v -> [Continue(state), Break(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
• 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, start_payloads : _state, U64 -> Try(_state, _err), next_payload : _state, U64, U64 -> Try(_state, _err), finish_payloads : _state, U64 -> Try(_state, _err), missing : _err } -> Try({ value : _shape, rest : _state }, _err)
• Encoding.Json
• Encoding.Json.parse_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_null : JsonEncoding, JsonState -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.parse_list_start : JsonEncoding, JsonState -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_list_next : JsonEncoding, JsonState -> Try([Item(JsonState), Done(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_list_after_item : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_tuple_start : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.parse_tuple_next : JsonEncoding, JsonState, U64, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.parse_tuple_end : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.encode_str : JsonEncoding, Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_bool : JsonEncoding, Bool, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_u8 : JsonEncoding, U8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_i8 : JsonEncoding, I8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_u16 : JsonEncoding, U16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_i16 : JsonEncoding, I16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_u32 : JsonEncoding, U32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_i32 : JsonEncoding, I32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_u64 : JsonEncoding, U64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_i64 : JsonEncoding, I64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_u128 : JsonEncoding, U128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_i128 : JsonEncoding, I128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_dec : JsonEncoding, Dec, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_f32 : JsonEncoding, F32, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])
• Encoding.Json.encode_f64 : JsonEncoding, F64, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])
• Encoding.Json.encode_null : JsonEncoding, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_tag : JsonEncoding, JsonEncodeState, Str, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)
• Encoding.Json.encode_record : JsonEncoding, JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)
• Encoding.Json.encode_tuple : JsonEncoding, JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)
• Encoding.Json.encode_list : JsonEncoding, JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)
• Encoding.Json.encode_dict : JsonEncoding, JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)), (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)
• Encoding.Json.to_str : a -> Str where [a.Encodable([])]
• Encoding.Json.to_str_try : a -> Try(Str, err) where [a.Encodable(err)]
• Encoding.Json.parse : Str -> Try(a, [InvalidJson(Str), ..errs]) where [a.Parseable([InvalidJson(Str), ..errs])]
• Encoding.Json.parse_trailing_commas : Str -> Try(a, [InvalidJson(Str), ..errs]) where [a.Parseable([InvalidJson(Str), ..errs])]
• Encoding.Json.parser_camel : () -> (Str -> Try(a, [InvalidJson(Str), ..errs])) where [a.Parseable([InvalidJson(Str), ..errs])]
• Encoding.Json.invalid_json : {} -> [InvalidJson(Str)]
• Encoding.Json.parse_json_bool : Str -> Try({ value : Bool, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_json_null : Str -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.parse_list_start_from_json : Str -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_list_next_from_json : Str -> Try([Item(JsonState), Done(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_list_after_item_from_json : JsonEncoding, Str -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_tuple_start_from_json : Str, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.parse_tuple_next_from_json : Str -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.parse_tuple_end_from_json : JsonEncoding, Str, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.parse_json_number_prefix : Str, (Str -> { err : U8, rest : Str, value : a }), (Str -> Bool) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_json_number : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.dec_from_json_number : Str -> Try(Dec, [BadNumStr])
• Encoding.Json.split_json_number_exponent : Str -> Try({ mantissa : Str, exponent : Str }, [NotFound])
• Encoding.Json.dec_from_json_exponent_parts : Str, Str -> Try(Dec, [BadNumStr])
• Encoding.Json.json_dec_digits_are_zero : Str -> Bool
• Encoding.Json.trim_json_dec_leading_zeros : Str, I64 -> { digits : Str, point : I64 }
• Encoding.Json.normalize_json_dec_digits : Bool, Str, I64 -> Try(Str, [BadNumStr])
• Encoding.Json.take_json_key : Str -> Try({ value : Str, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_json_key_unsigned_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_json_key_signed_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.parse_json_key_number : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.encode_json_number : Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.write_record_field : JsonContainerEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)
• Encoding.Json.write_dict_entry : JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)), (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)
• Encoding.Json.write_sequence_item : JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)
• 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_start_from_json : Str -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_record_field_from_json : Str -> Try([Field({ field : FieldName(_shape), rest : JsonState }), TryField({ name : Str, rest : JsonState }), TryFieldCaseless({ name : Str, rest : JsonState }), Continue(JsonState), Done(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_record_after_field_from_json : JsonEncoding, Str -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str)])
• Encoding.Json.parse_json_object_key : Str -> Try({ name : Str, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.snake_to_camel : Str -> Str
• Encoding.Json.upper_first_ascii : Str -> Str
• Encoding.Json.skip_json_value : JsonEncoding, JsonState -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.skip_json_object : JsonEncoding, Str -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.skip_json_array : JsonEncoding, Str -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.parse_tag_union_from_json : Str, JsonEncoding, ParseTagUnionSpec(a) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.start_string_tag_payloads : JsonState, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.next_string_tag_payload : JsonState, U64, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.finish_string_tag_payloads : JsonState, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.start_object_tag_payloads : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.next_object_tag_payload : JsonEncoding, JsonState, U64, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.finish_object_tag_payloads : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str)])
• Encoding.Json.finish_tag_payload : JsonEncoding, a, Str -> Try({ value : a, rest : JsonState }, [InvalidJson(Str)])
• Encoding.Json.consume_empty_json_object : Str -> Try({ after : Str }, [InvalidJson(Str)])
• Encoding.Json.is_json_scalar : Str -> Bool
• Encoding.Json.is_json_number : Str -> Bool
• Encoding.Json.is_json_u64_literal : Str -> Bool
• Encoding.Json.is_json_unsigned_int_literal : Str -> Bool
• Encoding.Json.is_json_signed_int_literal : Str -> Bool
• Encoding.Json.is_json_digit : U8 -> Bool
• Encoding.Json.is_json_digit_one_to_nine : U8 -> Bool
• Encoding.Json.is_json_exponent_marker : U8 -> Bool
• Encoding.Json.is_json_sign : U8 -> Bool
• Encoding.Json.split_json_string_tail : Str -> Try({ value : Str, after : Str }, [InvalidJson(Str)])
• Encoding.Json.split_json_scalar_tail : Str -> Try({ value : Str, after : Str }, [InvalidJson(Str)])
• Encoding.Json.Encodable : a where [a.encoder_for : JsonEncoding -> (a, JsonEncodeState -> Try(JsonEncodeState, err))]
• Encoding.Json.Parseable : a where [a.parser_for : JsonEncoding -> (JsonState -> Try({ value : a, rest : JsonState }, errs))]
• Encoding.HttpHeader
• Encoding.HttpHeader.parser_for : () -> (Str -> Try(output, [BadHeader, ..errs])) where [output.Parseable([BadHeader, ..errs])]
• Encoding.HttpHeader.parse : Str -> Try(output, [BadHeader, ..errs]) where [output.Parseable([BadHeader, ..errs])]
• Encoding.HttpHeader.parse_str : HttpHeaderEncoding, HttpHeaderState -> Try({ value : Str, rest : HttpHeaderState }, [BadHeader])
• Encoding.HttpHeader.parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, [BadHeader])
• Encoding.HttpHeader.parse_record_field_from_headers : FieldNames(_shape), Str -> Try([Field({ field : FieldName(_shape), rest : HttpHeaderState }), TryField({ name : Str, rest : HttpHeaderState }), TryFieldCaseless({ name : Str, rest : HttpHeaderState }), Continue(HttpHeaderState), Done(HttpHeaderState)], [BadHeader])
• Encoding.HttpHeader.take_header_value : Str -> Try({ value : Str, after : Str }, [BadHeader])
• Encoding.HttpHeader.underscores_to_dashes : Str -> Str
• Encoding.HttpHeader.Parseable : output where [output.parser_for : HttpHeaderEncoding -> (HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, errs))]
• Hasher
• 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
• Iter.custom : state, [Known(U64), Unknown], (state -> Try((item, state), [NoMore])) -> Iter(item)
• 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.with_index : Iter(a) -> Iter((U64, a))
• 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.sum : Iter(item) -> item where [item.plus : item, item -> item, item.default : () -> item]
• Iter.product : Iter(item) -> Try(item, [IterWasEmpty]) where [item.times : item, item -> item]
• Iter.min : Iter(item) -> Try(item, [IterWasEmpty]) where [item.min : item, item -> item]
• Iter.max : Iter(item) -> Try(item, [IterWasEmpty]) where [item.max : item, item -> item]
• 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.step_by : Iter(item), U64 -> Iter(item)
• List
• List.parser_for : _
• List.len : List(_item) -> U64
• List.capacity : List(_item) -> U64
• List.is_empty : List(_item) -> Bool
• List.iter : List(item) -> Iter(item)
• List.iter_rev : List(item) -> Iter(item)
• List.from_iter : Iter(item) -> List(item)
• List.concat : List(item), List(item) -> List(item)
• List.join : List(List(item)) -> List(item)
• List.join_map : List(a), (a -> List(b)) -> List(b)
• List.intersperse : List(a), a -> List(a)
• List.with_capacity : U64 -> List(item)
• List.reserve : List(item), U64 -> List(item)
• List.release_excess_capacity : List(item) -> List(item)
• List.sort : List(item) -> List(item) where [item.Sort]
• List.sort_by : List(item), (item -> field) -> List(item) where [field.Sort]
• List.sort_with : List(item), (item, item -> [Before, Same, After]) -> List(item)
• List.sort_reversed : List(item) -> List(item) where [item.Sort]
• List.sort_by_reversed : List(item), (item -> field) -> List(item) where [field.Sort]
• List.sort_with_reversed : List(item), (item, item -> [Before, Same, After]) -> List(item)
• List.is_eq : List(item), List(item) -> Bool where [item.is_eq : item, item -> Bool]
• List.to_hash : List(item), Hasher -> Hasher where [item.to_hash : item, Hasher -> Hasher]
• List.append : List(a), a -> List(a)
• List.append_if_ok : List(a), Try(a, err) -> List(a)
• List.append_range_within : List(a), U64, U64 -> Try(List(a), [OutOfBounds])
• List.copy_range_within : List(a), U64, U64, U64 -> Try(List(a), [OutOfBounds])
• List.append_sublist : List(a), List(a), { start : U64, len : U64 } -> List(a)
• List.prepend_if_ok : List(a), Try(a, err) -> List(a)
• List.prepend : List(a), a -> List(a)
• List.first : List(item) -> Try(item, [ListWasEmpty])
• List.get : List(item), U64 -> Try(item, [OutOfBounds])
• List.prefetched : List(item), U64 -> List(item)
• List.subscript : List(item), U64 -> Try(item, [OutOfBounds])
• List.get_wrap : List(item), U64 -> Try(item, [ListWasEmpty])
• 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.insert : List(a), U64, a -> 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.map3 : List(a), List(b), List(c), (a, b, c -> d) -> List(d)
• List.map4 : List(a), List(b), List(c), List(d), (a, b, c, d -> e) -> List(e)
• List.keep_if : List(a), (a -> Bool) -> List(a)
• List.drop_if : List(a), (a -> Bool) -> List(a)
• List.keep_oks : List(before), (before -> Try(after, _err)) -> List(after)
• List.keep_errs : List(before), (before -> Try(_ok, after)) -> List(after)
• List.count_if : List(a), (a -> Bool) -> U64
• List.map_try : List(a), (a -> Try(b, err)) -> Try(List(b), err)
• List.map_try! : List(a), (a => Try(b, err)) => Try(List(b), err)
• List.keep_if_try : List(a), (a -> Try(Bool, err)) -> Try(List(a), err)
• List.keep_if_try! : List(a), (a => Try(Bool, err)) => Try(List(a), err)
• List.fold_try : List(item), state, (state, item -> Try(state, err)) -> Try(state, err)
• List.fold_try! : List(item), state, (state, item => Try(state, err)) => Try(state, err)
• 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.drop_swap : List(a), U64 -> List(a)
• List.sublist : List(a), { start : U64, len : U64 } -> List(a)
• List.chunks_of : List(a), U64 -> List(List(a))
• List.take_first : List(a), U64 -> List(a)
• List.clear : List(a) -> List(a)
• List.take_last : List(a), U64 -> List(a)
• List.drop_first : List(a), U64 -> List(a)
• List.drop_last : List(a), U64 -> List(a)
• List.find_first : List(a), (a -> Bool) -> Try(a, [NotFound])
• List.find_last : List(a), (a -> Bool) -> Try(a, [NotFound])
• List.find_first_index : List(a), (a -> Bool) -> Try(U64, [NotFound])
• List.find_last_index : List(a), (a -> Bool) -> Try(U64, [NotFound])
• List.split_at : List(a), U64 -> { before : List(a), others : List(a) }
• List.split_on : List(a), a -> List(List(a)) where [a.is_eq : a, a -> Bool]
• List.split_if : List(a), (a -> Bool) -> List(List(a))
• List.split_on_list : List(a), List(a) -> List(List(a)) where [a.is_eq : a, a -> Bool]
• List.split_first : List(a), a -> Try({ before : List(a), after : List(a) }, [NotFound]) where [a.is_eq : a, a -> Bool]
• List.split_last : List(a), a -> Try({ before : List(a), after : List(a) }, [NotFound]) where [a.is_eq : a, a -> Bool]
• List.repeat : a, U64 -> List(a)
• List.sum : List(item) -> item where [item.plus : item, item -> item, item.default : () -> item]
• List.min : List(a) -> Try(a, [ListWasEmpty]) where [a.min : a, a -> a]
• List.max : List(a) -> Try(a, [ListWasEmpty]) where [a.max : a, a -> a]
• List.encoder_for : encoding -> (List(item), state -> Try(state, err)) where [item.encoder_for : encoding -> (item, state -> Try(state, err)), encoding.encode_list : state, U64, (container_state, (container_state, (state -> Try(state, err)) -> Try(container_state, err)) -> Try(container_state, err)) -> Try(state, err)]
• List.decode : src, fmt -> (Try(List(item), err), src) where [fmt.decode_list : fmt, src, (src, fmt -> (Try(item, err), src)) -> (Try(List(item), err), src), item.decode : src, fmt -> (Try(item, err), src)]
• Num
• Num.RawOrder := [After, Before, Same]
• Num.Range
• Num.Range.custom : { lower : num, upper : num, step : num, upper_bound : [Exclusive, Inclusive], direction : [To, From], len_if_known : [Known(U64), Unknown] } -> Range(num)
• Num.Range.size_hint : Range(num) -> [Known(U64), Unknown]
• Num.Range.step_by : Range(num), num -> Range(num) where [num.range_len_if_known : num, num, num, [Exclusive, Inclusive] -> [Known(U64), Unknown]]
• Num.Range.iter : Range(num) -> Iter(num) where [num.range_iter : num, num, num, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(num)]
• Num.Range.iter_rev : Range(num) -> Iter(num) where [num.range_exclusive_to : num, num -> Range(num), num.range_inclusive_to : num, num -> Range(num), num.range_exclusive_from : num, num -> Range(num), num.range_inclusive_from : num, num -> Range(num), num.range_len_if_known : num, num, num, [Exclusive, Inclusive] -> [Known(U64), Unknown], num.range_iter : num, num, num, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(num)]
• Num.Numeral
• Num.Numeral.is_negative : Numeral -> Bool
• Num.Numeral.digits_before_pt : Numeral -> List(U8)
• Num.Numeral.digits_after_pt : Numeral -> List(U8)
• Num.Numeral.digits_after_pt_count : Numeral -> U64
• Num.U8
• Num.U8.parser_for : _
• Num.U8.encoder_for : _
• Num.U8.default : () -> U8
• Num.U8.highest : U8
• Num.U8.lowest : U8
• Num.U8.to_str : U8 -> Str
• Num.U8.is_zero : U8 -> Bool
• Num.U8.is_eq : U8, U8 -> Bool
• Num.U8.to_hash : U8, Hasher -> Hasher
• Num.U8.is_gt : U8, U8 -> Bool
• Num.U8.is_gte : U8, U8 -> Bool
• Num.U8.is_lt : U8, U8 -> Bool
• Num.U8.is_lte : U8, U8 -> Bool
• Num.U8.order_relative_to : U8, U8 -> [Before, Same, After]
• 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.plus_wrap : U8, U8 -> U8
• Num.U8.plus_overflows : U8, U8 -> Bool
• Num.U8.plus_try : U8, U8 -> Try(U8, [Overflow])
• Num.U8.range_len_if_known : U8, U8, U8, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.U8.range_iter : U8, U8, U8, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(U8)
• Num.U8.range_exclusive_to : U8, U8 -> Range(U8)
• Num.U8.range_inclusive_to : U8, U8 -> Range(U8)
• Num.U8.range_exclusive_from : U8, U8 -> Range(U8)
• Num.U8.range_inclusive_from : U8, U8 -> Range(U8)
• Num.U8.plus_saturated : U8, U8 -> U8
• Num.U8.minus : U8, U8 -> U8
• Num.U8.minus_wrap : U8, U8 -> U8
• Num.U8.minus_overflows : U8, U8 -> Bool
• Num.U8.minus_try : U8, U8 -> Try(U8, [Overflow])
• Num.U8.minus_saturated : U8, U8 -> U8
• Num.U8.times : U8, U8 -> U8
• Num.U8.times_wrap : U8, U8 -> U8
• Num.U8.times_overflows : U8, U8 -> Bool
• Num.U8.times_try : U8, U8 -> Try(U8, [Overflow])
• Num.U8.times_saturated : U8, U8 -> U8
• Num.U8.pow : U8, U8 -> U8
• Num.U8.pow_try : U8, U8 -> Try(U8, [Overflow])
• Num.U8.div_by : U8, U8 -> U8
• Num.U8.div_try : U8, U8 -> Try(U8, [DivByZero])
• Num.U8.div_ceil_by : U8, U8 -> U8
• Num.U8.div_ceil_try : U8, U8 -> Try(U8, [DivByZero])
• Num.U8.div_floor_by : U8, U8 -> U8
• Num.U8.div_trunc_by : U8, U8 -> U8
• Num.U8.rem_by : U8, U8 -> U8
• Num.U8.mod_by : U8, U8 -> U8
• Num.U8.abs_diff : U8, U8 -> U8
• Num.U8.shl_wrap : U8, U8 -> U8
• Num.U8.shr_wrap : U8, U8 -> U8
• Num.U8.shr_zf_wrap : 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.from_str_prefix : Str -> Try({ value : U8, rest : Str }, [OutOfRange, NotANumber])
• Num.U8.from_utf8_prefix : List(U8) -> Try({ value : U8, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.U8.to : U8, U8 -> Iter(U8)
• Num.U8.until : U8, U8 -> Iter(U8)
• Num.U8.to_i8_wrap : U8 -> I8
• Num.U8.to_i8_try : U8 -> Try(I8, [OutOfRange])
• Num.U8.to_i16 : U8 -> I16
• Num.U8.to_i32 : U8 -> I32
• Num.U8.to_i64 : U8 -> I64
• Num.U8.to_i128 : U8 -> I128
• Num.U8.to_u8 : U8 -> U8
• Num.U8.to_u8_try : U8 -> Try(U8, _never_fails)
• Num.U8.to_u8_wrap : U8 -> U8
• Num.U8.to_u16 : U8 -> U16
• Num.U8.to_u32 : U8 -> U32
• Num.U8.to_u64 : U8 -> U64
• Num.U8.to_u128 : U8 -> U128
• Num.U8.to_f32 : U8 -> F32
• Num.U8.to_f64 : U8 -> F64
• Num.U8.to_dec : U8 -> Dec
• Num.U8.encode : U8, fmt -> Try(encoded, err) where [fmt.encode_u8 : fmt, U8 -> Try(encoded, err)]
• Num.U8.decode : src, fmt -> (Try(U8, err), src) where [fmt.decode_u8 : fmt, src -> (Try(U8, err), src)]
• Num.I8
• Num.I8.parser_for : _
• Num.I8.encoder_for : _
• Num.I8.default : () -> I8
• Num.I8.highest : I8
• Num.I8.lowest : I8
• Num.I8.to_str : I8 -> Str
• Num.I8.is_zero : I8 -> Bool
• Num.I8.is_negative : I8 -> Bool
• Num.I8.is_positive : I8 -> Bool
• Num.I8.is_eq : I8, I8 -> Bool
• Num.I8.to_hash : I8, Hasher -> Hasher
• Num.I8.is_gt : I8, I8 -> Bool
• Num.I8.is_gte : I8, I8 -> Bool
• Num.I8.is_lt : I8, I8 -> Bool
• Num.I8.is_lte : I8, I8 -> Bool
• Num.I8.order_relative_to : I8, I8 -> [Before, Same, After]
• 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.plus_wrap : I8, I8 -> I8
• Num.I8.plus_overflows : I8, I8 -> Bool
• Num.I8.plus_try : I8, I8 -> Try(I8, [Overflow])
• Num.I8.range_len_if_known : I8, I8, I8, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.I8.range_iter : I8, I8, I8, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(I8)
• Num.I8.range_exclusive_to : I8, I8 -> Range(I8)
• Num.I8.range_inclusive_to : I8, I8 -> Range(I8)
• Num.I8.range_exclusive_from : I8, I8 -> Range(I8)
• Num.I8.range_inclusive_from : I8, I8 -> Range(I8)
• Num.I8.plus_saturated : I8, I8 -> I8
• Num.I8.minus : I8, I8 -> I8
• Num.I8.minus_wrap : I8, I8 -> I8
• Num.I8.minus_overflows : I8, I8 -> Bool
• Num.I8.minus_try : I8, I8 -> Try(I8, [Overflow])
• Num.I8.minus_saturated : I8, I8 -> I8
• Num.I8.times : I8, I8 -> I8
• Num.I8.times_wrap : I8, I8 -> I8
• Num.I8.times_overflows : I8, I8 -> Bool
• Num.I8.times_try : I8, I8 -> Try(I8, [Overflow])
• Num.I8.times_saturated : I8, I8 -> I8
• Num.I8.pow : I8, I8 -> I8
• Num.I8.pow_try : I8, I8 -> Try(I8, [Overflow, Underflow])
• Num.I8.div_by : I8, I8 -> I8
• Num.I8.div_try : I8, I8 -> Try(I8, [DivByZero, Overflow])
• Num.I8.div_ceil_by : I8, I8 -> I8
• Num.I8.div_ceil_try : I8, I8 -> Try(I8, [DivByZero, Overflow])
• Num.I8.div_floor_by : I8, I8 -> I8
• Num.I8.div_trunc_by : I8, I8 -> I8
• Num.I8.rem_by : I8, I8 -> I8
• Num.I8.mod_by : I8, I8 -> I8
• Num.I8.abs_diff : I8, I8 -> U8
• Num.I8.shl_wrap : I8, U8 -> I8
• Num.I8.shr_wrap : I8, U8 -> I8
• Num.I8.shr_zf_wrap : 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.from_str_prefix : Str -> Try({ value : I8, rest : Str }, [OutOfRange, NotANumber])
• Num.I8.from_utf8_prefix : List(U8) -> Try({ value : I8, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.I8.to_i8 : I8 -> I8
• Num.I8.to_i8_try : I8 -> Try(I8, _never_fails)
• Num.I8.to_i8_wrap : I8 -> I8
• Num.I8.to_i16 : I8 -> I16
• Num.I8.to_i32 : I8 -> I32
• Num.I8.to_i64 : I8 -> I64
• Num.I8.to_i128 : I8 -> I128
• Num.I8.to_u8_wrap : I8 -> U8
• Num.I8.to_u8_try : I8 -> Try(U8, [OutOfRange])
• Num.I8.to_u16_wrap : I8 -> U16
• Num.I8.to_u16_try : I8 -> Try(U16, [OutOfRange])
• Num.I8.to_u32_wrap : I8 -> U32
• Num.I8.to_u32_try : I8 -> Try(U32, [OutOfRange])
• Num.I8.to_u64_wrap : I8 -> U64
• Num.I8.to_u64_try : I8 -> Try(U64, [OutOfRange])
• Num.I8.to_u128_wrap : I8 -> U128
• Num.I8.to_u128_try : I8 -> Try(U128, [OutOfRange])
• Num.I8.to_f32 : I8 -> F32
• Num.I8.to_f64 : I8 -> F64
• Num.I8.to_dec : I8 -> Dec
• Num.I8.encode : I8, fmt -> Try(encoded, err) where [fmt.encode_i8 : fmt, I8 -> Try(encoded, err)]
• Num.I8.decode : src, fmt -> (Try(I8, err), src) where [fmt.decode_i8 : fmt, src -> (Try(I8, err), src)]
• Num.U16
• Num.U16.parser_for : _
• Num.U16.encoder_for : _
• Num.U16.default : () -> U16
• Num.U16.highest : U16
• Num.U16.lowest : U16
• Num.U16.to_str : U16 -> Str
• Num.U16.is_zero : U16 -> Bool
• Num.U16.is_eq : U16, U16 -> Bool
• Num.U16.to_hash : U16, Hasher -> Hasher
• Num.U16.is_gt : U16, U16 -> Bool
• Num.U16.is_gte : U16, U16 -> Bool
• Num.U16.is_lt : U16, U16 -> Bool
• Num.U16.is_lte : U16, U16 -> Bool
• Num.U16.order_relative_to : U16, U16 -> [Before, Same, After]
• 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.plus_wrap : U16, U16 -> U16
• Num.U16.plus_overflows : U16, U16 -> Bool
• Num.U16.plus_try : U16, U16 -> Try(U16, [Overflow])
• Num.U16.range_len_if_known : U16, U16, U16, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.U16.range_iter : U16, U16, U16, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(U16)
• Num.U16.range_exclusive_to : U16, U16 -> Range(U16)
• Num.U16.range_inclusive_to : U16, U16 -> Range(U16)
• Num.U16.range_exclusive_from : U16, U16 -> Range(U16)
• Num.U16.range_inclusive_from : U16, U16 -> Range(U16)
• Num.U16.plus_saturated : U16, U16 -> U16
• Num.U16.minus : U16, U16 -> U16
• Num.U16.minus_wrap : U16, U16 -> U16
• Num.U16.minus_overflows : U16, U16 -> Bool
• Num.U16.minus_try : U16, U16 -> Try(U16, [Overflow])
• Num.U16.minus_saturated : U16, U16 -> U16
• Num.U16.times : U16, U16 -> U16
• Num.U16.times_wrap : U16, U16 -> U16
• Num.U16.times_overflows : U16, U16 -> Bool
• Num.U16.times_try : U16, U16 -> Try(U16, [Overflow])
• Num.U16.times_saturated : U16, U16 -> U16
• Num.U16.pow : U16, U16 -> U16
• Num.U16.pow_try : U16, U16 -> Try(U16, [Overflow])
• Num.U16.div_by : U16, U16 -> U16
• Num.U16.div_try : U16, U16 -> Try(U16, [DivByZero])
• Num.U16.div_ceil_by : U16, U16 -> U16
• Num.U16.div_ceil_try : U16, U16 -> Try(U16, [DivByZero])
• Num.U16.div_floor_by : U16, U16 -> U16
• Num.U16.div_trunc_by : U16, U16 -> U16
• Num.U16.rem_by : U16, U16 -> U16
• Num.U16.mod_by : U16, U16 -> U16
• Num.U16.abs_diff : U16, U16 -> U16
• Num.U16.shl_wrap : U16, U8 -> U16
• Num.U16.shr_wrap : U16, U8 -> U16
• Num.U16.shr_zf_wrap : 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.from_le_bytes : List(U8), U64 -> Try(U16, [OutOfBounds])
• 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.from_str_prefix : Str -> Try({ value : U16, rest : Str }, [OutOfRange, NotANumber])
• Num.U16.from_utf8_prefix : List(U8) -> Try({ value : U16, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.U16.to_i8_wrap : U16 -> I8
• Num.U16.to_i8_try : U16 -> Try(I8, [OutOfRange])
• Num.U16.to_i16_wrap : U16 -> I16
• Num.U16.to_i16_try : U16 -> Try(I16, [OutOfRange])
• Num.U16.to_i32 : U16 -> I32
• Num.U16.to_i64 : U16 -> I64
• Num.U16.to_i128 : U16 -> I128
• Num.U16.to_u8_wrap : U16 -> U8
• Num.U16.to_u8_try : U16 -> Try(U8, [OutOfRange])
• Num.U16.to_u16 : U16 -> U16
• Num.U16.to_u16_try : U16 -> Try(U16, _never_fails)
• Num.U16.to_u16_wrap : U16 -> U16
• Num.U16.to_u32 : U16 -> U32
• Num.U16.to_u64 : U16 -> U64
• Num.U16.to_u128 : U16 -> U128
• Num.U16.to_f32 : U16 -> F32
• Num.U16.to_f64 : U16 -> F64
• Num.U16.to_dec : U16 -> Dec
• Num.U16.encode : U16, fmt -> Try(encoded, err) where [fmt.encode_u16 : fmt, U16 -> Try(encoded, err)]
• Num.U16.decode : src, fmt -> (Try(U16, err), src) where [fmt.decode_u16 : fmt, src -> (Try(U16, err), src)]
• Num.I16
• Num.I16.parser_for : _
• Num.I16.encoder_for : _
• Num.I16.default : () -> I16
• Num.I16.highest : I16
• Num.I16.lowest : I16
• Num.I16.to_str : I16 -> Str
• Num.I16.is_zero : I16 -> Bool
• Num.I16.is_negative : I16 -> Bool
• Num.I16.is_positive : I16 -> Bool
• Num.I16.is_eq : I16, I16 -> Bool
• Num.I16.to_hash : I16, Hasher -> Hasher
• Num.I16.is_gt : I16, I16 -> Bool
• Num.I16.is_gte : I16, I16 -> Bool
• Num.I16.is_lt : I16, I16 -> Bool
• Num.I16.is_lte : I16, I16 -> Bool
• Num.I16.order_relative_to : I16, I16 -> [Before, Same, After]
• 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.plus_wrap : I16, I16 -> I16
• Num.I16.plus_overflows : I16, I16 -> Bool
• Num.I16.plus_try : I16, I16 -> Try(I16, [Overflow])
• Num.I16.range_len_if_known : I16, I16, I16, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.I16.range_iter : I16, I16, I16, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(I16)
• Num.I16.range_exclusive_to : I16, I16 -> Range(I16)
• Num.I16.range_inclusive_to : I16, I16 -> Range(I16)
• Num.I16.range_exclusive_from : I16, I16 -> Range(I16)
• Num.I16.range_inclusive_from : I16, I16 -> Range(I16)
• Num.I16.plus_saturated : I16, I16 -> I16
• Num.I16.minus : I16, I16 -> I16
• Num.I16.minus_wrap : I16, I16 -> I16
• Num.I16.minus_overflows : I16, I16 -> Bool
• Num.I16.minus_try : I16, I16 -> Try(I16, [Overflow])
• Num.I16.minus_saturated : I16, I16 -> I16
• Num.I16.times : I16, I16 -> I16
• Num.I16.times_wrap : I16, I16 -> I16
• Num.I16.times_overflows : I16, I16 -> Bool
• Num.I16.times_try : I16, I16 -> Try(I16, [Overflow])
• Num.I16.times_saturated : I16, I16 -> I16
• Num.I16.pow : I16, I16 -> I16
• Num.I16.pow_try : I16, I16 -> Try(I16, [Overflow, Underflow])
• Num.I16.div_by : I16, I16 -> I16
• Num.I16.div_try : I16, I16 -> Try(I16, [DivByZero, Overflow])
• Num.I16.div_ceil_by : I16, I16 -> I16
• Num.I16.div_ceil_try : I16, I16 -> Try(I16, [DivByZero, Overflow])
• Num.I16.div_floor_by : I16, I16 -> I16
• Num.I16.div_trunc_by : I16, I16 -> I16
• Num.I16.rem_by : I16, I16 -> I16
• Num.I16.mod_by : I16, I16 -> I16
• Num.I16.abs_diff : I16, I16 -> U16
• Num.I16.shl_wrap : I16, U8 -> I16
• Num.I16.shr_wrap : I16, U8 -> I16
• Num.I16.shr_zf_wrap : 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.from_le_bytes : List(U8), U64 -> Try(I16, [OutOfBounds])
• 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.from_str_prefix : Str -> Try({ value : I16, rest : Str }, [OutOfRange, NotANumber])
• Num.I16.from_utf8_prefix : List(U8) -> Try({ value : I16, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.I16.to_i8_wrap : I16 -> I8
• Num.I16.to_i8_try : I16 -> Try(I8, [OutOfRange])
• Num.I16.to_i16 : I16 -> I16
• Num.I16.to_i16_try : I16 -> Try(I16, _never_fails)
• Num.I16.to_i16_wrap : I16 -> I16
• Num.I16.to_i32 : I16 -> I32
• Num.I16.to_i64 : I16 -> I64
• Num.I16.to_i128 : I16 -> I128
• Num.I16.to_u8_wrap : I16 -> U8
• Num.I16.to_u8_try : I16 -> Try(U8, [OutOfRange])
• Num.I16.to_u16_wrap : I16 -> U16
• Num.I16.to_u16_try : I16 -> Try(U16, [OutOfRange])
• Num.I16.to_u32_wrap : I16 -> U32
• Num.I16.to_u32_try : I16 -> Try(U32, [OutOfRange])
• Num.I16.to_u64_wrap : I16 -> U64
• Num.I16.to_u64_try : I16 -> Try(U64, [OutOfRange])
• Num.I16.to_u128_wrap : I16 -> U128
• Num.I16.to_u128_try : I16 -> Try(U128, [OutOfRange])
• Num.I16.to_f32 : I16 -> F32
• Num.I16.to_f64 : I16 -> F64
• Num.I16.to_dec : I16 -> Dec
• Num.I16.encode : I16, fmt -> Try(encoded, err) where [fmt.encode_i16 : fmt, I16 -> Try(encoded, err)]
• Num.I16.decode : src, fmt -> (Try(I16, err), src) where [fmt.decode_i16 : fmt, src -> (Try(I16, err), src)]
• Num.U32
• Num.U32.parser_for : _
• Num.U32.encoder_for : _
• Num.U32.default : () -> U32
• Num.U32.highest : U32
• Num.U32.lowest : U32
• Num.U32.to_str : U32 -> Str
• Num.U32.is_zero : U32 -> Bool
• Num.U32.is_eq : U32, U32 -> Bool
• Num.U32.to_hash : U32, Hasher -> Hasher
• Num.U32.is_gt : U32, U32 -> Bool
• Num.U32.is_gte : U32, U32 -> Bool
• Num.U32.is_lt : U32, U32 -> Bool
• Num.U32.is_lte : U32, U32 -> Bool
• Num.U32.order_relative_to : U32, U32 -> [Before, Same, After]
• 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.plus_wrap : U32, U32 -> U32
• Num.U32.plus_overflows : U32, U32 -> Bool
• Num.U32.plus_try : U32, U32 -> Try(U32, [Overflow])
• Num.U32.range_len_if_known : U32, U32, U32, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.U32.range_iter : U32, U32, U32, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(U32)
• Num.U32.range_exclusive_to : U32, U32 -> Range(U32)
• Num.U32.range_inclusive_to : U32, U32 -> Range(U32)
• Num.U32.range_exclusive_from : U32, U32 -> Range(U32)
• Num.U32.range_inclusive_from : U32, U32 -> Range(U32)
• Num.U32.plus_saturated : U32, U32 -> U32
• Num.U32.minus : U32, U32 -> U32
• Num.U32.minus_wrap : U32, U32 -> U32
• Num.U32.minus_overflows : U32, U32 -> Bool
• Num.U32.minus_try : U32, U32 -> Try(U32, [Overflow])
• Num.U32.minus_saturated : U32, U32 -> U32
• Num.U32.times : U32, U32 -> U32
• Num.U32.times_wrap : U32, U32 -> U32
• Num.U32.times_overflows : U32, U32 -> Bool
• Num.U32.times_try : U32, U32 -> Try(U32, [Overflow])
• Num.U32.times_saturated : U32, U32 -> U32
• Num.U32.pow : U32, U32 -> U32
• Num.U32.pow_try : U32, U32 -> Try(U32, [Overflow])
• Num.U32.div_by : U32, U32 -> U32
• Num.U32.div_try : U32, U32 -> Try(U32, [DivByZero])
• Num.U32.div_ceil_by : U32, U32 -> U32
• Num.U32.div_ceil_try : U32, U32 -> Try(U32, [DivByZero])
• Num.U32.div_floor_by : U32, U32 -> U32
• Num.U32.div_trunc_by : U32, U32 -> U32
• Num.U32.rem_by : U32, U32 -> U32
• Num.U32.mod_by : U32, U32 -> U32
• Num.U32.abs_diff : U32, U32 -> U32
• Num.U32.shl_wrap : U32, U8 -> U32
• Num.U32.shr_wrap : U32, U8 -> U32
• Num.U32.shr_zf_wrap : 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.from_le_bytes : List(U8), U64 -> Try(U32, [OutOfBounds])
• 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.from_str_prefix : Str -> Try({ value : U32, rest : Str }, [OutOfRange, NotANumber])
• Num.U32.from_utf8_prefix : List(U8) -> Try({ value : U32, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.U32.to_i8_wrap : U32 -> I8
• Num.U32.to_i8_try : U32 -> Try(I8, [OutOfRange])
• Num.U32.to_i16_wrap : U32 -> I16
• Num.U32.to_i16_try : U32 -> Try(I16, [OutOfRange])
• Num.U32.to_i32_wrap : U32 -> I32
• Num.U32.to_i32_try : U32 -> Try(I32, [OutOfRange])
• Num.U32.to_i64 : U32 -> I64
• Num.U32.to_i128 : U32 -> I128
• Num.U32.to_u8_wrap : U32 -> U8
• Num.U32.to_u8_try : U32 -> Try(U8, [OutOfRange])
• Num.U32.to_u16_wrap : U32 -> U16
• Num.U32.to_u16_try : U32 -> Try(U16, [OutOfRange])
• Num.U32.to_u32 : U32 -> U32
• Num.U32.to_u32_try : U32 -> Try(U32, _never_fails)
• Num.U32.to_u32_wrap : U32 -> U32
• Num.U32.to_u64 : U32 -> U64
• Num.U32.to_u128 : U32 -> U128
• Num.U32.to_f32 : U32 -> F32
• Num.U32.to_f64 : U32 -> F64
• Num.U32.to_dec : U32 -> Dec
• Num.U32.encode : U32, fmt -> Try(encoded, err) where [fmt.encode_u32 : fmt, U32 -> Try(encoded, err)]
• Num.U32.decode : src, fmt -> (Try(U32, err), src) where [fmt.decode_u32 : fmt, src -> (Try(U32, err), src)]
• Num.I32
• Num.I32.parser_for : _
• Num.I32.encoder_for : _
• Num.I32.default : () -> I32
• Num.I32.highest : I32
• Num.I32.lowest : I32
• Num.I32.to_str : I32 -> Str
• Num.I32.is_zero : I32 -> Bool
• Num.I32.is_negative : I32 -> Bool
• Num.I32.is_positive : I32 -> Bool
• Num.I32.is_eq : I32, I32 -> Bool
• Num.I32.to_hash : I32, Hasher -> Hasher
• Num.I32.is_gt : I32, I32 -> Bool
• Num.I32.is_gte : I32, I32 -> Bool
• Num.I32.is_lt : I32, I32 -> Bool
• Num.I32.is_lte : I32, I32 -> Bool
• Num.I32.order_relative_to : I32, I32 -> [Before, Same, After]
• 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.plus_wrap : I32, I32 -> I32
• Num.I32.plus_overflows : I32, I32 -> Bool
• Num.I32.plus_try : I32, I32 -> Try(I32, [Overflow])
• Num.I32.range_len_if_known : I32, I32, I32, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.I32.range_iter : I32, I32, I32, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(I32)
• Num.I32.range_exclusive_to : I32, I32 -> Range(I32)
• Num.I32.range_inclusive_to : I32, I32 -> Range(I32)
• Num.I32.range_exclusive_from : I32, I32 -> Range(I32)
• Num.I32.range_inclusive_from : I32, I32 -> Range(I32)
• Num.I32.plus_saturated : I32, I32 -> I32
• Num.I32.minus : I32, I32 -> I32
• Num.I32.minus_wrap : I32, I32 -> I32
• Num.I32.minus_overflows : I32, I32 -> Bool
• Num.I32.minus_try : I32, I32 -> Try(I32, [Overflow])
• Num.I32.minus_saturated : I32, I32 -> I32
• Num.I32.times : I32, I32 -> I32
• Num.I32.times_wrap : I32, I32 -> I32
• Num.I32.times_overflows : I32, I32 -> Bool
• Num.I32.times_try : I32, I32 -> Try(I32, [Overflow])
• Num.I32.times_saturated : I32, I32 -> I32
• Num.I32.pow : I32, I32 -> I32
• Num.I32.pow_try : I32, I32 -> Try(I32, [Overflow, Underflow])
• Num.I32.div_by : I32, I32 -> I32
• Num.I32.div_try : I32, I32 -> Try(I32, [DivByZero, Overflow])
• Num.I32.div_ceil_by : I32, I32 -> I32
• Num.I32.div_ceil_try : I32, I32 -> Try(I32, [DivByZero, Overflow])
• Num.I32.div_floor_by : I32, I32 -> I32
• Num.I32.div_trunc_by : I32, I32 -> I32
• Num.I32.rem_by : I32, I32 -> I32
• Num.I32.mod_by : I32, I32 -> I32
• Num.I32.abs_diff : I32, I32 -> U32
• Num.I32.shl_wrap : I32, U8 -> I32
• Num.I32.shr_wrap : I32, U8 -> I32
• Num.I32.shr_zf_wrap : 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.from_le_bytes : List(U8), U64 -> Try(I32, [OutOfBounds])
• 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.from_str_prefix : Str -> Try({ value : I32, rest : Str }, [OutOfRange, NotANumber])
• Num.I32.from_utf8_prefix : List(U8) -> Try({ value : I32, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.I32.to_i8_wrap : I32 -> I8
• Num.I32.to_i8_try : I32 -> Try(I8, [OutOfRange])
• Num.I32.to_i16_wrap : I32 -> I16
• Num.I32.to_i16_try : I32 -> Try(I16, [OutOfRange])
• Num.I32.to_i32 : I32 -> I32
• Num.I32.to_i32_try : I32 -> Try(I32, _never_fails)
• Num.I32.to_i32_wrap : I32 -> I32
• Num.I32.to_i64 : I32 -> I64
• Num.I32.to_i128 : I32 -> I128
• Num.I32.to_u8_wrap : I32 -> U8
• Num.I32.to_u8_try : I32 -> Try(U8, [OutOfRange])
• Num.I32.to_u16_wrap : I32 -> U16
• Num.I32.to_u16_try : I32 -> Try(U16, [OutOfRange])
• Num.I32.to_u32_wrap : I32 -> U32
• Num.I32.to_u32_try : I32 -> Try(U32, [OutOfRange])
• Num.I32.to_u64_wrap : I32 -> U64
• Num.I32.to_u64_try : I32 -> Try(U64, [OutOfRange])
• Num.I32.to_u128_wrap : I32 -> U128
• Num.I32.to_u128_try : I32 -> Try(U128, [OutOfRange])
• Num.I32.to_f32 : I32 -> F32
• Num.I32.to_f64 : I32 -> F64
• Num.I32.to_dec : I32 -> Dec
• Num.I32.encode : I32, fmt -> Try(encoded, err) where [fmt.encode_i32 : fmt, I32 -> Try(encoded, err)]
• Num.I32.decode : src, fmt -> (Try(I32, err), src) where [fmt.decode_i32 : fmt, src -> (Try(I32, err), src)]
• Num.U64
• Num.U64.parser_for : _
• Num.U64.encoder_for : _
• Num.U64.default : () -> U64
• Num.U64.highest : U64
• Num.U64.lowest : U64
• Num.U64.to_str : U64 -> Str
• Num.U64.is_zero : U64 -> Bool
• Num.U64.is_eq : U64, U64 -> Bool
• Num.U64.to_hash : U64, Hasher -> Hasher
• Num.U64.is_gt : U64, U64 -> Bool
• Num.U64.is_gte : U64, U64 -> Bool
• Num.U64.is_lt : U64, U64 -> Bool
• Num.U64.is_lte : U64, U64 -> Bool
• Num.U64.order_relative_to : U64, U64 -> [Before, Same, After]
• 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.plus_wrap : U64, U64 -> U64
• Num.U64.plus_overflows : U64, U64 -> Bool
• Num.U64.plus_try : U64, U64 -> Try(U64, [Overflow])
• Num.U64.range_len_if_known : U64, U64, U64, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.U64.range_iter : U64, U64, U64, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(U64)
• Num.U64.range_exclusive_to : U64, U64 -> Range(U64)
• Num.U64.range_inclusive_to : U64, U64 -> Range(U64)
• Num.U64.range_exclusive_from : U64, U64 -> Range(U64)
• Num.U64.range_inclusive_from : U64, U64 -> Range(U64)
• Num.U64.plus_saturated : U64, U64 -> U64
• Num.U64.minus : U64, U64 -> U64
• Num.U64.minus_wrap : U64, U64 -> U64
• Num.U64.minus_overflows : U64, U64 -> Bool
• Num.U64.minus_try : U64, U64 -> Try(U64, [Overflow])
• Num.U64.minus_saturated : U64, U64 -> U64
• Num.U64.times : U64, U64 -> U64
• Num.U64.times_wrap : U64, U64 -> U64
• Num.U64.times_overflows : U64, U64 -> Bool
• Num.U64.times_try : U64, U64 -> Try(U64, [Overflow])
• Num.U64.times_saturated : U64, U64 -> U64
• Num.U64.pow : U64, U64 -> U64
• Num.U64.pow_try : U64, U64 -> Try(U64, [Overflow])
• Num.U64.div_by : U64, U64 -> U64
• Num.U64.div_try : U64, U64 -> Try(U64, [DivByZero])
• Num.U64.div_ceil_by : U64, U64 -> U64
• Num.U64.div_ceil_try : U64, U64 -> Try(U64, [DivByZero])
• Num.U64.div_floor_by : U64, U64 -> U64
• Num.U64.div_trunc_by : U64, U64 -> U64
• Num.U64.rem_by : U64, U64 -> U64
• Num.U64.mod_by : U64, U64 -> U64
• Num.U64.abs_diff : U64, U64 -> U64
• Num.U64.shl_wrap : U64, U8 -> U64
• Num.U64.shr_wrap : U64, U8 -> U64
• Num.U64.shr_zf_wrap : 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.from_le_bytes : List(U8), U64 -> Try(U64, [OutOfBounds])
• Num.U64.append_le_bytes_to : U64, List(U8), U8 -> Try(List(U8), [OutOfBounds])
• 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.from_str_prefix : Str -> Try({ value : U64, rest : Str }, [OutOfRange, NotANumber])
• Num.U64.from_utf8_prefix : List(U8) -> Try({ value : U64, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.U64.to_i8_wrap : U64 -> I8
• Num.U64.to_i8_try : U64 -> Try(I8, [OutOfRange])
• Num.U64.to_i16_wrap : U64 -> I16
• Num.U64.to_i16_try : U64 -> Try(I16, [OutOfRange])
• Num.U64.to_i32_wrap : U64 -> I32
• Num.U64.to_i32_try : U64 -> Try(I32, [OutOfRange])
• Num.U64.to_i64_wrap : U64 -> I64
• Num.U64.to_i64_try : U64 -> Try(I64, [OutOfRange])
• Num.U64.to_i128 : U64 -> I128
• Num.U64.to_u8_wrap : U64 -> U8
• Num.U64.to_u8_try : U64 -> Try(U8, [OutOfRange])
• Num.U64.to_u16_wrap : U64 -> U16
• Num.U64.to_u16_try : U64 -> Try(U16, [OutOfRange])
• Num.U64.to_u32_wrap : U64 -> U32
• Num.U64.to_u32_try : U64 -> Try(U32, [OutOfRange])
• Num.U64.to_u64 : U64 -> U64
• Num.U64.to_u64_try : U64 -> Try(U64, _never_fails)
• Num.U64.to_u64_wrap : U64 -> U64
• Num.U64.to_u128 : U64 -> U128
• Num.U64.to_f32 : U64 -> F32
• Num.U64.to_f64 : U64 -> F64
• Num.U64.to_dec : U64 -> Dec
• Num.U64.encode : U64, fmt -> Try(encoded, err) where [fmt.encode_u64 : fmt, U64 -> Try(encoded, err)]
• Num.U64.decode : src, fmt -> (Try(U64, err), src) where [fmt.decode_u64 : fmt, src -> (Try(U64, err), src)]
• Num.I64
• Num.I64.parser_for : _
• Num.I64.encoder_for : _
• Num.I64.default : () -> I64
• Num.I64.highest : I64
• Num.I64.lowest : I64
• Num.I64.to_str : I64 -> Str
• Num.I64.is_zero : I64 -> Bool
• Num.I64.is_negative : I64 -> Bool
• Num.I64.is_positive : I64 -> Bool
• Num.I64.is_eq : I64, I64 -> Bool
• Num.I64.to_hash : I64, Hasher -> Hasher
• Num.I64.is_gt : I64, I64 -> Bool
• Num.I64.is_gte : I64, I64 -> Bool
• Num.I64.is_lt : I64, I64 -> Bool
• Num.I64.is_lte : I64, I64 -> Bool
• Num.I64.order_relative_to : I64, I64 -> [Before, Same, After]
• 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.plus_wrap : I64, I64 -> I64
• Num.I64.plus_overflows : I64, I64 -> Bool
• Num.I64.plus_try : I64, I64 -> Try(I64, [Overflow])
• Num.I64.range_len_if_known : I64, I64, I64, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.I64.range_iter : I64, I64, I64, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(I64)
• Num.I64.range_exclusive_to : I64, I64 -> Range(I64)
• Num.I64.range_inclusive_to : I64, I64 -> Range(I64)
• Num.I64.range_exclusive_from : I64, I64 -> Range(I64)
• Num.I64.range_inclusive_from : I64, I64 -> Range(I64)
• Num.I64.plus_saturated : I64, I64 -> I64
• Num.I64.minus : I64, I64 -> I64
• Num.I64.minus_wrap : I64, I64 -> I64
• Num.I64.minus_overflows : I64, I64 -> Bool
• Num.I64.minus_try : I64, I64 -> Try(I64, [Overflow])
• Num.I64.minus_saturated : I64, I64 -> I64
• Num.I64.times : I64, I64 -> I64
• Num.I64.times_wrap : I64, I64 -> I64
• Num.I64.times_overflows : I64, I64 -> Bool
• Num.I64.times_try : I64, I64 -> Try(I64, [Overflow])
• Num.I64.times_saturated : I64, I64 -> I64
• Num.I64.pow : I64, I64 -> I64
• Num.I64.pow_try : I64, I64 -> Try(I64, [Overflow, Underflow])
• Num.I64.div_by : I64, I64 -> I64
• Num.I64.div_try : I64, I64 -> Try(I64, [DivByZero, Overflow])
• Num.I64.div_ceil_by : I64, I64 -> I64
• Num.I64.div_ceil_try : I64, I64 -> Try(I64, [DivByZero, Overflow])
• Num.I64.div_floor_by : I64, I64 -> I64
• Num.I64.div_trunc_by : I64, I64 -> I64
• Num.I64.rem_by : I64, I64 -> I64
• Num.I64.mod_by : I64, I64 -> I64
• Num.I64.abs_diff : I64, I64 -> U64
• Num.I64.shl_wrap : I64, U8 -> I64
• Num.I64.shr_wrap : I64, U8 -> I64
• Num.I64.shr_zf_wrap : 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.from_le_bytes : List(U8), U64 -> Try(I64, [OutOfBounds])
• 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.from_str_prefix : Str -> Try({ value : I64, rest : Str }, [OutOfRange, NotANumber])
• Num.I64.from_utf8_prefix : List(U8) -> Try({ value : I64, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.I64.to_i8_wrap : I64 -> I8
• Num.I64.to_i8_try : I64 -> Try(I8, [OutOfRange])
• Num.I64.to_i16_wrap : I64 -> I16
• Num.I64.to_i16_try : I64 -> Try(I16, [OutOfRange])
• Num.I64.to_i32_wrap : I64 -> I32
• Num.I64.to_i32_try : I64 -> Try(I32, [OutOfRange])
• Num.I64.to_i64 : I64 -> I64
• Num.I64.to_i64_try : I64 -> Try(I64, _never_fails)
• Num.I64.to_i64_wrap : I64 -> I64
• Num.I64.to_i128 : I64 -> I128
• Num.I64.to_u8_wrap : I64 -> U8
• Num.I64.to_u8_try : I64 -> Try(U8, [OutOfRange])
• Num.I64.to_u16_wrap : I64 -> U16
• Num.I64.to_u16_try : I64 -> Try(U16, [OutOfRange])
• Num.I64.to_u32_wrap : I64 -> U32
• Num.I64.to_u32_try : I64 -> Try(U32, [OutOfRange])
• Num.I64.to_u64_wrap : I64 -> U64
• Num.I64.to_u64_try : I64 -> Try(U64, [OutOfRange])
• Num.I64.to_u128_wrap : I64 -> U128
• Num.I64.to_u128_try : I64 -> Try(U128, [OutOfRange])
• Num.I64.to_f32 : I64 -> F32
• Num.I64.to_f64 : I64 -> F64
• Num.I64.to_dec : I64 -> Dec
• Num.I64.encode : I64, fmt -> Try(encoded, err) where [fmt.encode_i64 : fmt, I64 -> Try(encoded, err)]
• Num.I64.decode : src, fmt -> (Try(I64, err), src) where [fmt.decode_i64 : fmt, src -> (Try(I64, err), src)]
• Num.U128
• Num.U128.parser_for : _
• Num.U128.encoder_for : _
• Num.U128.default : () -> U128
• Num.U128.highest : U128
• Num.U128.lowest : U128
• Num.U128.to_str : U128 -> Str
• Num.U128.is_zero : U128 -> Bool
• Num.U128.is_eq : U128, U128 -> Bool
• Num.U128.to_hash : U128, Hasher -> Hasher
• Num.U128.is_gt : U128, U128 -> Bool
• Num.U128.is_gte : U128, U128 -> Bool
• Num.U128.is_lt : U128, U128 -> Bool
• Num.U128.is_lte : U128, U128 -> Bool
• Num.U128.order_relative_to : U128, U128 -> [Before, Same, After]
• 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.plus_wrap : U128, U128 -> U128
• Num.U128.plus_overflows : U128, U128 -> Bool
• Num.U128.plus_try : U128, U128 -> Try(U128, [Overflow])
• Num.U128.range_len_if_known : U128, U128, U128, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.U128.range_iter : U128, U128, U128, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(U128)
• Num.U128.range_exclusive_to : U128, U128 -> Range(U128)
• Num.U128.range_inclusive_to : U128, U128 -> Range(U128)
• Num.U128.range_exclusive_from : U128, U128 -> Range(U128)
• Num.U128.range_inclusive_from : U128, U128 -> Range(U128)
• Num.U128.plus_saturated : U128, U128 -> U128
• Num.U128.minus : U128, U128 -> U128
• Num.U128.minus_wrap : U128, U128 -> U128
• Num.U128.minus_overflows : U128, U128 -> Bool
• Num.U128.minus_try : U128, U128 -> Try(U128, [Overflow])
• Num.U128.minus_saturated : U128, U128 -> U128
• Num.U128.times : U128, U128 -> U128
• Num.U128.times_wrap : U128, U128 -> U128
• Num.U128.times_overflows : U128, U128 -> Bool
• Num.U128.times_try : U128, U128 -> Try(U128, [Overflow])
• Num.U128.times_saturated : U128, U128 -> U128
• Num.U128.pow : U128, U128 -> U128
• Num.U128.pow_try : U128, U128 -> Try(U128, [Overflow])
• Num.U128.div_by : U128, U128 -> U128
• Num.U128.div_try : U128, U128 -> Try(U128, [DivByZero])
• Num.U128.div_ceil_by : U128, U128 -> U128
• Num.U128.div_ceil_try : U128, U128 -> Try(U128, [DivByZero])
• Num.U128.div_floor_by : U128, U128 -> U128
• Num.U128.div_trunc_by : U128, U128 -> U128
• Num.U128.rem_by : U128, U128 -> U128
• Num.U128.mod_by : U128, U128 -> U128
• Num.U128.abs_diff : U128, U128 -> U128
• Num.U128.shl_wrap : U128, U8 -> U128
• Num.U128.shr_wrap : U128, U8 -> U128
• Num.U128.shr_zf_wrap : 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.from_le_bytes : List(U8), U64 -> Try(U128, [OutOfBounds])
• 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.from_str_prefix : Str -> Try({ value : U128, rest : Str }, [OutOfRange, NotANumber])
• Num.U128.from_utf8_prefix : List(U8) -> Try({ value : U128, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.U128.to_i8_wrap : U128 -> I8
• Num.U128.to_i8_try : U128 -> Try(I8, [OutOfRange])
• Num.U128.to_i16_wrap : U128 -> I16
• Num.U128.to_i16_try : U128 -> Try(I16, [OutOfRange])
• Num.U128.to_i32_wrap : U128 -> I32
• Num.U128.to_i32_try : U128 -> Try(I32, [OutOfRange])
• Num.U128.to_i64_wrap : U128 -> I64
• Num.U128.to_i64_try : U128 -> Try(I64, [OutOfRange])
• Num.U128.to_i128_wrap : U128 -> I128
• Num.U128.to_i128_try : U128 -> Try(I128, [OutOfRange])
• Num.U128.to_u8_wrap : U128 -> U8
• Num.U128.to_u8_try : U128 -> Try(U8, [OutOfRange])
• Num.U128.to_u16_wrap : U128 -> U16
• Num.U128.to_u16_try : U128 -> Try(U16, [OutOfRange])
• Num.U128.to_u32_wrap : U128 -> U32
• Num.U128.to_u32_try : U128 -> Try(U32, [OutOfRange])
• Num.U128.to_u64_wrap : U128 -> U64
• Num.U128.to_u64_try : U128 -> Try(U64, [OutOfRange])
• Num.U128.to_u128 : U128 -> U128
• Num.U128.to_u128_try : U128 -> Try(U128, _never_fails)
• Num.U128.to_u128_wrap : U128 -> U128
• Num.U128.to_f32 : U128 -> F32
• Num.U128.to_f64 : U128 -> F64
• Num.U128.to_dec_try : U128 -> Try(Dec, [OutOfRange])
• Num.U128.encode : U128, fmt -> Try(encoded, err) where [fmt.encode_u128 : fmt, U128 -> Try(encoded, err)]
• Num.U128.decode : src, fmt -> (Try(U128, err), src) where [fmt.decode_u128 : fmt, src -> (Try(U128, err), src)]
• Num.I128
• Num.I128.parser_for : _
• Num.I128.encoder_for : _
• Num.I128.default : () -> I128
• Num.I128.highest : I128
• Num.I128.lowest : I128
• Num.I128.to_str : I128 -> Str
• Num.I128.is_zero : I128 -> Bool
• Num.I128.is_negative : I128 -> Bool
• Num.I128.is_positive : I128 -> Bool
• Num.I128.is_eq : I128, I128 -> Bool
• Num.I128.to_hash : I128, Hasher -> Hasher
• Num.I128.is_gt : I128, I128 -> Bool
• Num.I128.is_gte : I128, I128 -> Bool
• Num.I128.is_lt : I128, I128 -> Bool
• Num.I128.is_lte : I128, I128 -> Bool
• Num.I128.order_relative_to : I128, I128 -> [Before, Same, After]
• 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.plus_wrap : I128, I128 -> I128
• Num.I128.plus_overflows : I128, I128 -> Bool
• Num.I128.plus_try : I128, I128 -> Try(I128, [Overflow])
• Num.I128.range_len_if_known : I128, I128, I128, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.I128.range_iter : I128, I128, I128, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(I128)
• Num.I128.range_exclusive_to : I128, I128 -> Range(I128)
• Num.I128.range_inclusive_to : I128, I128 -> Range(I128)
• Num.I128.range_exclusive_from : I128, I128 -> Range(I128)
• Num.I128.range_inclusive_from : I128, I128 -> Range(I128)
• Num.I128.plus_saturated : I128, I128 -> I128
• Num.I128.minus : I128, I128 -> I128
• Num.I128.minus_wrap : I128, I128 -> I128
• Num.I128.minus_overflows : I128, I128 -> Bool
• Num.I128.minus_try : I128, I128 -> Try(I128, [Overflow])
• Num.I128.minus_saturated : I128, I128 -> I128
• Num.I128.times : I128, I128 -> I128
• Num.I128.times_wrap : I128, I128 -> I128
• Num.I128.times_overflows : I128, I128 -> Bool
• Num.I128.times_try : I128, I128 -> Try(I128, [Overflow])
• Num.I128.times_saturated : I128, I128 -> I128
• Num.I128.pow : I128, I128 -> I128
• Num.I128.pow_try : I128, I128 -> Try(I128, [Overflow, Underflow])
• Num.I128.div_by : I128, I128 -> I128
• Num.I128.div_try : I128, I128 -> Try(I128, [DivByZero, Overflow])
• Num.I128.div_ceil_by : I128, I128 -> I128
• Num.I128.div_ceil_try : I128, I128 -> Try(I128, [DivByZero, Overflow])
• Num.I128.div_floor_by : I128, I128 -> I128
• Num.I128.div_trunc_by : I128, I128 -> I128
• Num.I128.rem_by : I128, I128 -> I128
• Num.I128.mod_by : I128, I128 -> I128
• Num.I128.abs_diff : I128, I128 -> U128
• Num.I128.shl_wrap : I128, U8 -> I128
• Num.I128.shr_wrap : I128, U8 -> I128
• Num.I128.shr_zf_wrap : 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.from_le_bytes : List(U8), U64 -> Try(I128, [OutOfBounds])
• 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.from_str_prefix : Str -> Try({ value : I128, rest : Str }, [OutOfRange, NotANumber])
• Num.I128.from_utf8_prefix : List(U8) -> Try({ value : I128, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.I128.to_i8_wrap : I128 -> I8
• Num.I128.to_i8_try : I128 -> Try(I8, [OutOfRange])
• Num.I128.to_i16_wrap : I128 -> I16
• Num.I128.to_i16_try : I128 -> Try(I16, [OutOfRange])
• Num.I128.to_i32_wrap : I128 -> I32
• Num.I128.to_i32_try : I128 -> Try(I32, [OutOfRange])
• Num.I128.to_i64_wrap : I128 -> I64
• Num.I128.to_i64_try : I128 -> Try(I64, [OutOfRange])
• Num.I128.to_i128 : I128 -> I128
• Num.I128.to_i128_try : I128 -> Try(I128, _never_fails)
• Num.I128.to_i128_wrap : I128 -> I128
• Num.I128.to_u8_wrap : I128 -> U8
• Num.I128.to_u8_try : I128 -> Try(U8, [OutOfRange])
• Num.I128.to_u16_wrap : I128 -> U16
• Num.I128.to_u16_try : I128 -> Try(U16, [OutOfRange])
• Num.I128.to_u32_wrap : I128 -> U32
• Num.I128.to_u32_try : I128 -> Try(U32, [OutOfRange])
• Num.I128.to_u64_wrap : I128 -> U64
• Num.I128.to_u64_try : I128 -> Try(U64, [OutOfRange])
• Num.I128.to_u128_wrap : I128 -> U128
• Num.I128.to_u128_try : I128 -> Try(U128, [OutOfRange])
• Num.I128.to_f32 : I128 -> F32
• Num.I128.to_f64 : I128 -> F64
• Num.I128.to_dec_try : I128 -> Try(Dec, [OutOfRange])
• Num.I128.encode : I128, fmt -> Try(encoded, err) where [fmt.encode_i128 : fmt, I128 -> Try(encoded, err)]
• Num.I128.decode : src, fmt -> (Try(I128, err), src) where [fmt.decode_i128 : fmt, src -> (Try(I128, err), src)]
• Num.Dec
• Num.Dec.parser_for : _
• Num.Dec.encoder_for : _
• Num.Dec.default : () -> Dec
• Num.Dec.highest : Dec
• Num.Dec.lowest : Dec
• Num.Dec.e : Dec
• Num.Dec.pi : Dec
• Num.Dec.tau : Dec
• Num.Dec.to_attos : Dec -> I128
• Num.Dec.from_attos : I128 -> 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.order_relative_to : Dec, Dec -> [Before, Same, After]
• Num.Dec.max : Dec, Dec -> Dec
• Num.Dec.min : Dec, Dec -> Dec
• Num.Dec.is_approx_eq : Dec, Dec, { rel : Dec, abs : Dec } -> Bool
• Num.Dec.negate : Dec -> Dec
• Num.Dec.abs : Dec -> Dec
• Num.Dec.plus : Dec, Dec -> Dec
• Num.Dec.plus_try : Dec, Dec -> Try(Dec, [Overflow])
• Num.Dec.range_len_if_known : Dec, Dec, Dec, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.Dec.range_iter : Dec, Dec, Dec, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(Dec)
• Num.Dec.range_exclusive_to : Dec, Dec -> Range(Dec)
• Num.Dec.range_inclusive_to : Dec, Dec -> Range(Dec)
• Num.Dec.range_exclusive_from : Dec, Dec -> Range(Dec)
• Num.Dec.range_inclusive_from : Dec, Dec -> Range(Dec)
• Num.Dec.plus_saturated : Dec, Dec -> Dec
• Num.Dec.minus : Dec, Dec -> Dec
• Num.Dec.minus_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.atan2 : { x : Dec, y : Dec } -> Dec
• Num.Dec.div_by : Dec, Dec -> Dec
• Num.Dec.div_trunc_by : Dec, Dec -> Dec
• Num.Dec.div_floor_by : Dec, Dec -> Dec
• Num.Dec.rem_by : Dec, Dec -> Dec
• Num.Dec.abs_diff : Dec, Dec -> Dec
• Num.Dec.round : Dec -> Dec
• Num.Dec.round_try : Dec -> Try(Dec, [Overflow])
• Num.Dec.floor : Dec -> Dec
• Num.Dec.floor_try : Dec -> Try(Dec, [Overflow])
• Num.Dec.ceiling : Dec -> Dec
• Num.Dec.ceiling_try : Dec -> Try(Dec, [Overflow])
• Num.Dec.trunc : Dec -> Dec
• Num.Dec.round_to : Dec, { step : Dec, ties : [AwayFromZero, ToEven] } -> Dec
• Num.Dec.round_to_try : Dec, { step : Dec, ties : [AwayFromZero, ToEven] } -> Try(Dec, [Overflow])
• Num.Dec.round_to_i8_try : Dec -> Try(I8, [OutOfRange])
• Num.Dec.round_to_i16_try : Dec -> Try(I16, [OutOfRange])
• Num.Dec.round_to_i32_try : Dec -> Try(I32, [OutOfRange])
• Num.Dec.round_to_i64_try : Dec -> Try(I64, [OutOfRange])
• Num.Dec.round_to_i128 : Dec -> I128
• Num.Dec.round_to_u8_try : Dec -> Try(U8, [OutOfRange])
• Num.Dec.round_to_u16_try : Dec -> Try(U16, [OutOfRange])
• Num.Dec.round_to_u32_try : Dec -> Try(U32, [OutOfRange])
• Num.Dec.round_to_u64_try : Dec -> Try(U64, [OutOfRange])
• Num.Dec.round_to_u128_try : Dec -> Try(U128, [OutOfRange])
• Num.Dec.floor_to_i8_try : Dec -> Try(I8, [OutOfRange])
• Num.Dec.floor_to_i16_try : Dec -> Try(I16, [OutOfRange])
• Num.Dec.floor_to_i32_try : Dec -> Try(I32, [OutOfRange])
• Num.Dec.floor_to_i64_try : Dec -> Try(I64, [OutOfRange])
• Num.Dec.floor_to_i128 : Dec -> I128
• Num.Dec.floor_to_u8_try : Dec -> Try(U8, [OutOfRange])
• Num.Dec.floor_to_u16_try : Dec -> Try(U16, [OutOfRange])
• Num.Dec.floor_to_u32_try : Dec -> Try(U32, [OutOfRange])
• Num.Dec.floor_to_u64_try : Dec -> Try(U64, [OutOfRange])
• Num.Dec.floor_to_u128_try : Dec -> Try(U128, [OutOfRange])
• Num.Dec.ceiling_to_i8_try : Dec -> Try(I8, [OutOfRange])
• Num.Dec.ceiling_to_i16_try : Dec -> Try(I16, [OutOfRange])
• Num.Dec.ceiling_to_i32_try : Dec -> Try(I32, [OutOfRange])
• Num.Dec.ceiling_to_i64_try : Dec -> Try(I64, [OutOfRange])
• Num.Dec.ceiling_to_i128 : Dec -> I128
• Num.Dec.ceiling_to_u8_try : Dec -> Try(U8, [OutOfRange])
• Num.Dec.ceiling_to_u16_try : Dec -> Try(U16, [OutOfRange])
• Num.Dec.ceiling_to_u32_try : Dec -> Try(U32, [OutOfRange])
• Num.Dec.ceiling_to_u64_try : Dec -> Try(U64, [OutOfRange])
• Num.Dec.ceiling_to_u128_try : Dec -> Try(U128, [OutOfRange])
• 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.from_str_prefix : Str -> Try({ value : Dec, rest : Str }, [OutOfRange, NotANumber])
• Num.Dec.from_utf8_prefix : List(U8) -> Try({ value : Dec, rest : List(U8) }, [OutOfRange, NotANumber])
• 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 : Dec -> I128
• Num.Dec.to_u8_wrap : Dec -> U8
• Num.Dec.to_u8_try : Dec -> Try(U8, [OutOfRange])
• Num.Dec.to_u16_wrap : Dec -> U16
• Num.Dec.to_u16_try : Dec -> Try(U16, [OutOfRange])
• Num.Dec.to_u32_wrap : Dec -> U32
• Num.Dec.to_u32_try : Dec -> Try(U32, [OutOfRange])
• Num.Dec.to_u64_wrap : Dec -> U64
• Num.Dec.to_u64_try : Dec -> Try(U64, [OutOfRange])
• Num.Dec.to_u128_wrap : Dec -> U128
• Num.Dec.to_u128_try : Dec -> Try(U128, [OutOfRange])
• Num.Dec.to_f32_wrap : Dec -> F32
• Num.Dec.to_f32_try : Dec -> Try(F32, [OutOfRange])
• Num.Dec.to_f64 : Dec -> F64
• Num.Dec.to_dec : Dec -> Dec
• Num.Dec.to_dec_try : Dec -> Try(Dec, _never_fails)
• Num.Dec.to : Dec, Dec -> Iter(Dec)
• Num.Dec.until : Dec, Dec -> Iter(Dec)
• Num.Dec.encode : Dec, fmt -> Try(encoded, err) where [fmt.encode_dec : fmt, Dec -> Try(encoded, err)]
• Num.Dec.decode : src, fmt -> (Try(Dec, err), src) where [fmt.decode_dec : fmt, src -> (Try(Dec, err), src)]
• Num.F32
• Num.F32.parser_for : _
• Num.F32.encoder_for : _
• Num.F32.default : () -> F32
• Num.F32.highest : F32
• Num.F32.lowest : F32
• Num.F32.nan : F32
• Num.F32.infinity : F32
• Num.F32.e : F32
• Num.F32.pi : F32
• Num.F32.tau : F32
• Num.F32.to_str : F32 -> Str
• Num.F32.to_bits : F32 -> U32
• Num.F32.from_bits : U32 -> F32
• Num.F32.is_nan : F32 -> Bool
• Num.F32.is_infinite : F32 -> Bool
• Num.F32.is_finite : F32 -> Bool
• Num.F32.is_zero : F32 -> Bool
• Num.F32.is_float_eq : F32, F32 -> Bool
• Num.F32.is_approx_eq : F32, F32, { rel : F32, abs : F32 } -> Bool
• Num.F32.is_eq : _
• Num.F32.to_hash : F32, Hasher -> Hasher
• Num.F32.is_negative : F32 -> Bool
• Num.F32.is_positive : F32 -> Bool
• Num.F32.is_gt : F32, F32 -> Bool
• Num.F32.is_gte : F32, F32 -> Bool
• Num.F32.is_lt : F32, F32 -> Bool
• Num.F32.is_lte : F32, F32 -> Bool
• Num.F32.max : F32, F32 -> F32
• Num.F32.min : F32, F32 -> F32
• Num.F32.negate : F32 -> F32
• Num.F32.abs : F32 -> F32
• Num.F32.sqrt : F32 -> F32
• Num.F32.sqrt_try : F32 -> Try(F32, [SqrtOfNegative])
• Num.F32.pow : F32, F32 -> F32
• Num.F32.sin : F32 -> F32
• Num.F32.cos : F32 -> F32
• Num.F32.tan : F32 -> F32
• Num.F32.asin : F32 -> F32
• Num.F32.acos : F32 -> F32
• Num.F32.atan : F32 -> F32
• Num.F32.atan2 : { x : F32, y : F32 } -> F32
• Num.F32.plus : F32, F32 -> F32
• Num.F32.minus : F32, F32 -> F32
• Num.F32.times : F32, F32 -> F32
• Num.F32.div_by : F32, F32 -> F32
• Num.F32.div_trunc_by : F32, F32 -> F32
• Num.F32.div_floor_by : F32, F32 -> F32
• Num.F32.rem_by : F32, F32 -> F32
• Num.F32.abs_diff : F32, F32 -> F32
• Num.F32.round_to_i8_try : F32 -> Try(I8, [OutOfRange])
• Num.F32.round_to_i16_try : F32 -> Try(I16, [OutOfRange])
• Num.F32.round_to_i32_try : F32 -> Try(I32, [OutOfRange])
• Num.F32.round_to_i64_try : F32 -> Try(I64, [OutOfRange])
• Num.F32.round_to_i128_try : F32 -> Try(I128, [OutOfRange])
• Num.F32.round_to_u8_try : F32 -> Try(U8, [OutOfRange])
• Num.F32.round_to_u16_try : F32 -> Try(U16, [OutOfRange])
• Num.F32.round_to_u32_try : F32 -> Try(U32, [OutOfRange])
• Num.F32.round_to_u64_try : F32 -> Try(U64, [OutOfRange])
• Num.F32.round_to_u128_try : F32 -> Try(U128, [OutOfRange])
• Num.F32.floor_to_i8_try : F32 -> Try(I8, [OutOfRange])
• Num.F32.floor_to_i16_try : F32 -> Try(I16, [OutOfRange])
• Num.F32.floor_to_i32_try : F32 -> Try(I32, [OutOfRange])
• Num.F32.floor_to_i64_try : F32 -> Try(I64, [OutOfRange])
• Num.F32.floor_to_i128_try : F32 -> Try(I128, [OutOfRange])
• Num.F32.floor_to_u8_try : F32 -> Try(U8, [OutOfRange])
• Num.F32.floor_to_u16_try : F32 -> Try(U16, [OutOfRange])
• Num.F32.floor_to_u32_try : F32 -> Try(U32, [OutOfRange])
• Num.F32.floor_to_u64_try : F32 -> Try(U64, [OutOfRange])
• Num.F32.floor_to_u128_try : F32 -> Try(U128, [OutOfRange])
• Num.F32.ceiling_to_i8_try : F32 -> Try(I8, [OutOfRange])
• Num.F32.ceiling_to_i16_try : F32 -> Try(I16, [OutOfRange])
• Num.F32.ceiling_to_i32_try : F32 -> Try(I32, [OutOfRange])
• Num.F32.ceiling_to_i64_try : F32 -> Try(I64, [OutOfRange])
• Num.F32.ceiling_to_i128_try : F32 -> Try(I128, [OutOfRange])
• Num.F32.ceiling_to_u8_try : F32 -> Try(U8, [OutOfRange])
• Num.F32.ceiling_to_u16_try : F32 -> Try(U16, [OutOfRange])
• Num.F32.ceiling_to_u32_try : F32 -> Try(U32, [OutOfRange])
• Num.F32.ceiling_to_u64_try : F32 -> Try(U64, [OutOfRange])
• Num.F32.ceiling_to_u128_try : F32 -> Try(U128, [OutOfRange])
• Num.F32.from_int_digits : List(U8) -> Try(F32, [OutOfRange])
• Num.F32.from_dec_digits : (List(U8), List(U8)) -> Try(F32, [OutOfRange])
• Num.F32.from_numeral : Numeral -> Try(F32, [InvalidNumeral(Str)])
• Num.F32.range_len_if_known : F32, F32, F32, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.F32.range_iter : F32, F32, F32, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(F32)
• Num.F32.range_exclusive_to : F32, F32 -> Range(F32)
• Num.F32.range_inclusive_to : F32, F32 -> Range(F32)
• Num.F32.from_str : Str -> Try(F32, [BadNumStr])
• Num.F32.from_str_prefix : Str -> Try({ value : F32, rest : Str }, [OutOfRange, NotANumber])
• Num.F32.from_utf8_prefix : List(U8) -> Try({ value : F32, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.F32.to_i8_wrap : F32 -> I8
• Num.F32.to_i8_try : F32 -> Try(I8, [OutOfRange])
• Num.F32.to_i16_wrap : F32 -> I16
• Num.F32.to_i16_try : F32 -> Try(I16, [OutOfRange])
• Num.F32.to_i32_wrap : F32 -> I32
• Num.F32.to_i32_try : F32 -> Try(I32, [OutOfRange])
• Num.F32.to_i64_wrap : F32 -> I64
• Num.F32.to_i64_try : F32 -> Try(I64, [OutOfRange])
• Num.F32.to_i128_wrap : F32 -> I128
• Num.F32.to_i128_try : F32 -> Try(I128, [OutOfRange])
• Num.F32.to_u8_wrap : F32 -> U8
• Num.F32.to_u8_try : F32 -> Try(U8, [OutOfRange])
• Num.F32.to_u16_wrap : F32 -> U16
• Num.F32.to_u16_try : F32 -> Try(U16, [OutOfRange])
• Num.F32.to_u32_wrap : F32 -> U32
• Num.F32.to_u32_try : F32 -> Try(U32, [OutOfRange])
• Num.F32.to_u64_wrap : F32 -> U64
• Num.F32.to_u64_try : F32 -> Try(U64, [OutOfRange])
• Num.F32.to_u128_wrap : F32 -> U128
• Num.F32.to_u128_try : F32 -> Try(U128, [OutOfRange])
• Num.F32.to_f32 : F32 -> F32
• Num.F32.to_f32_wrap : F32 -> F32
• Num.F32.to_f32_try : F32 -> Try(F32, _never_fails)
• Num.F32.to_f64 : F32 -> F64
• Num.F32.encode : F32, fmt -> Try(encoded, err) where [fmt.encode_f32 : fmt, F32 -> Try(encoded, err)]
• Num.F32.decode : src, fmt -> (Try(F32, err), src) where [fmt.decode_f32 : fmt, src -> (Try(F32, err), src)]
• Num.F64
• Num.F64.parser_for : _
• Num.F64.encoder_for : _
• Num.F64.default : () -> F64
• Num.F64.highest : F64
• Num.F64.lowest : F64
• Num.F64.nan : F64
• Num.F64.infinity : F64
• Num.F64.e : F64
• Num.F64.pi : F64
• Num.F64.tau : F64
• Num.F64.to_str : F64 -> Str
• Num.F64.to_bits : F64 -> U64
• Num.F64.from_bits : U64 -> F64
• Num.F64.is_nan : F64 -> Bool
• Num.F64.is_infinite : F64 -> Bool
• Num.F64.is_finite : F64 -> Bool
• Num.F64.is_zero : F64 -> Bool
• Num.F64.is_float_eq : F64, F64 -> Bool
• Num.F64.is_approx_eq : F64, F64, { rel : F64, abs : F64 } -> Bool
• Num.F64.is_eq : _
• Num.F64.to_hash : F64, Hasher -> Hasher
• Num.F64.is_negative : F64 -> Bool
• Num.F64.is_positive : F64 -> Bool
• Num.F64.is_gt : F64, F64 -> Bool
• Num.F64.is_gte : F64, F64 -> Bool
• Num.F64.is_lt : F64, F64 -> Bool
• Num.F64.is_lte : F64, F64 -> Bool
• Num.F64.max : F64, F64 -> F64
• Num.F64.min : F64, F64 -> F64
• Num.F64.negate : F64 -> F64
• Num.F64.abs : F64 -> F64
• Num.F64.sqrt : F64 -> F64
• Num.F64.sqrt_try : F64 -> Try(F64, [SqrtOfNegative])
• Num.F64.pow : F64, F64 -> F64
• Num.F64.sin : F64 -> F64
• Num.F64.cos : F64 -> F64
• Num.F64.tan : F64 -> F64
• Num.F64.asin : F64 -> F64
• Num.F64.acos : F64 -> F64
• Num.F64.atan : F64 -> F64
• Num.F64.atan2 : { x : F64, y : F64 } -> F64
• Num.F64.plus : F64, F64 -> F64
• Num.F64.minus : F64, F64 -> F64
• Num.F64.times : F64, F64 -> F64
• Num.F64.div_by : F64, F64 -> F64
• Num.F64.div_trunc_by : F64, F64 -> F64
• Num.F64.div_floor_by : F64, F64 -> F64
• Num.F64.rem_by : F64, F64 -> F64
• Num.F64.abs_diff : F64, F64 -> F64
• Num.F64.round_to_i8_try : F64 -> Try(I8, [OutOfRange])
• Num.F64.round_to_i16_try : F64 -> Try(I16, [OutOfRange])
• Num.F64.round_to_i32_try : F64 -> Try(I32, [OutOfRange])
• Num.F64.round_to_i64_try : F64 -> Try(I64, [OutOfRange])
• Num.F64.round_to_i128_try : F64 -> Try(I128, [OutOfRange])
• Num.F64.round_to_u8_try : F64 -> Try(U8, [OutOfRange])
• Num.F64.round_to_u16_try : F64 -> Try(U16, [OutOfRange])
• Num.F64.round_to_u32_try : F64 -> Try(U32, [OutOfRange])
• Num.F64.round_to_u64_try : F64 -> Try(U64, [OutOfRange])
• Num.F64.round_to_u128_try : F64 -> Try(U128, [OutOfRange])
• Num.F64.floor_to_i8_try : F64 -> Try(I8, [OutOfRange])
• Num.F64.floor_to_i16_try : F64 -> Try(I16, [OutOfRange])
• Num.F64.floor_to_i32_try : F64 -> Try(I32, [OutOfRange])
• Num.F64.floor_to_i64_try : F64 -> Try(I64, [OutOfRange])
• Num.F64.floor_to_i128_try : F64 -> Try(I128, [OutOfRange])
• Num.F64.floor_to_u8_try : F64 -> Try(U8, [OutOfRange])
• Num.F64.floor_to_u16_try : F64 -> Try(U16, [OutOfRange])
• Num.F64.floor_to_u32_try : F64 -> Try(U32, [OutOfRange])
• Num.F64.floor_to_u64_try : F64 -> Try(U64, [OutOfRange])
• Num.F64.floor_to_u128_try : F64 -> Try(U128, [OutOfRange])
• Num.F64.ceiling_to_i8_try : F64 -> Try(I8, [OutOfRange])
• Num.F64.ceiling_to_i16_try : F64 -> Try(I16, [OutOfRange])
• Num.F64.ceiling_to_i32_try : F64 -> Try(I32, [OutOfRange])
• Num.F64.ceiling_to_i64_try : F64 -> Try(I64, [OutOfRange])
• Num.F64.ceiling_to_i128_try : F64 -> Try(I128, [OutOfRange])
• Num.F64.ceiling_to_u8_try : F64 -> Try(U8, [OutOfRange])
• Num.F64.ceiling_to_u16_try : F64 -> Try(U16, [OutOfRange])
• Num.F64.ceiling_to_u32_try : F64 -> Try(U32, [OutOfRange])
• Num.F64.ceiling_to_u64_try : F64 -> Try(U64, [OutOfRange])
• Num.F64.ceiling_to_u128_try : F64 -> Try(U128, [OutOfRange])
• Num.F64.from_int_digits : List(U8) -> Try(F64, [OutOfRange])
• Num.F64.from_dec_digits : (List(U8), List(U8)) -> Try(F64, [OutOfRange])
• Num.F64.from_numeral : Numeral -> Try(F64, [InvalidNumeral(Str)])
• Num.F64.range_len_if_known : F64, F64, F64, [Exclusive, Inclusive] -> [Known(U64), Unknown]
• Num.F64.range_iter : F64, F64, F64, [Exclusive, Inclusive], [To, From], [Known(U64), Unknown] -> Iter(F64)
• Num.F64.range_exclusive_to : F64, F64 -> Range(F64)
• Num.F64.range_inclusive_to : F64, F64 -> Range(F64)
• Num.F64.from_str : Str -> Try(F64, [BadNumStr])
• Num.F64.from_str_prefix : Str -> Try({ value : F64, rest : Str }, [OutOfRange, NotANumber])
• Num.F64.from_utf8_prefix : List(U8) -> Try({ value : F64, rest : List(U8) }, [OutOfRange, NotANumber])
• Num.F64.to_i8_wrap : F64 -> I8
• Num.F64.to_i8_try : F64 -> Try(I8, [OutOfRange])
• Num.F64.to_i16_wrap : F64 -> I16
• Num.F64.to_i16_try : F64 -> Try(I16, [OutOfRange])
• Num.F64.to_i32_wrap : F64 -> I32
• Num.F64.to_i32_try : F64 -> Try(I32, [OutOfRange])
• Num.F64.to_i64_wrap : F64 -> I64
• Num.F64.to_i64_try : F64 -> Try(I64, [OutOfRange])
• Num.F64.to_i128_wrap : F64 -> I128
• Num.F64.to_i128_try : F64 -> Try(I128, [OutOfRange])
• Num.F64.to_u8_wrap : F64 -> U8
• Num.F64.to_u8_try : F64 -> Try(U8, [OutOfRange])
• Num.F64.to_u16_wrap : F64 -> U16
• Num.F64.to_u16_try : F64 -> Try(U16, [OutOfRange])
• Num.F64.to_u32_wrap : F64 -> U32
• Num.F64.to_u32_try : F64 -> Try(U32, [OutOfRange])
• Num.F64.to_u64_wrap : F64 -> U64
• Num.F64.to_u64_try : F64 -> Try(U64, [OutOfRange])
• Num.F64.to_u128_wrap : F64 -> U128
• Num.F64.to_u128_try : F64 -> Try(U128, [OutOfRange])
• Num.F64.to_f32_wrap : F64 -> F32
• Num.F64.to_f32_try : F64 -> Try(F32, [OutOfRange])
• Num.F64.to_f64 : F64 -> F64
• Num.F64.to_f64_wrap : F64 -> F64
• Num.F64.to_f64_try : F64 -> Try(F64, _never_fails)
• Num.F64.encode : F64, fmt -> Try(encoded, err) where [fmt.encode_f64 : fmt, F64 -> Try(encoded, err)]
• Num.F64.decode : src, fmt -> (Try(F64, err), src) where [fmt.decode_f64 : fmt, src -> (Try(F64, err), src)]
• Num.U8x16
• Num.U8x16.default : () -> U8x16
• Num.U8x16.splat : U8 -> U8x16
• Num.U8x16.from_list : List(U8) -> Try(U8x16, [WrongLength])
• Num.U8x16.to_list : U8x16 -> List(U8)
• Num.U8x16.is_eq : U8x16, U8x16 -> Bool
• Num.U8x16.to_hash : U8x16, Hasher -> Hasher
• Num.U8x16.to_inspect : U8x16 -> Str
• Num.U8x16.to_u128_bits : U8x16 -> U128
• Num.U8x16.from_u128_bits : U128 -> U8x16
• Num.U8x16.to_i8x16_bits : U8x16 -> I8x16
• Num.U8x16.to_u16x8_bits : U8x16 -> U16x8
• Num.U8x16.to_i16x8_bits : U8x16 -> I16x8
• Num.U8x16.to_u32x4_bits : U8x16 -> U32x4
• Num.U8x16.to_i32x4_bits : U8x16 -> I32x4
• Num.U8x16.to_u64x2_bits : U8x16 -> U64x2
• Num.U8x16.to_i64x2_bits : U8x16 -> I64x2
• Num.U8x16.plus_wrap : U8x16, U8x16 -> U8x16
• Num.U8x16.minus_wrap : U8x16, U8x16 -> U8x16
• Num.U8x16.plus_saturated : U8x16, U8x16 -> U8x16
• Num.U8x16.minus_saturated : U8x16, U8x16 -> U8x16
• Num.U8x16.min : U8x16, U8x16 -> U8x16
• Num.U8x16.max : U8x16, U8x16 -> U8x16
• Num.U8x16.abs_diff : U8x16, U8x16 -> U8x16
• Num.U8x16.avg_rounded : U8x16, U8x16 -> U8x16
• Num.U8x16.bitwise_and : U8x16, U8x16 -> U8x16
• Num.U8x16.bitwise_or : U8x16, U8x16 -> U8x16
• Num.U8x16.bitwise_xor : U8x16, U8x16 -> U8x16
• Num.U8x16.bitwise_not : U8x16 -> U8x16
• Num.U8x16.bit_select : U8x16, U8x16, U8x16 -> U8x16
• Num.U8x16.eq_lanes : U8x16, U8x16 -> U8x16
• Num.U8x16.gt_lanes : U8x16, U8x16 -> U8x16
• Num.U8x16.lt_lanes : U8x16, U8x16 -> U8x16
• Num.U8x16.gte_lanes : U8x16, U8x16 -> U8x16
• Num.U8x16.lte_lanes : U8x16, U8x16 -> U8x16
• Num.U8x16.to_bitmask : U8x16 -> U16
• Num.U8x16.any_lanes_set : U8x16 -> Bool
• Num.U8x16.all_lanes_set : U8x16 -> Bool
• Num.U8x16.shl_wrap : U8x16, U8 -> U8x16
• Num.U8x16.shr_wrap : U8x16, U8 -> U8x16
• Num.U8x16.shr_zf_wrap : U8x16, U8 -> U8x16
• Num.U8x16.get_lane : U8x16, U64 -> U8
• Num.U8x16.with_lane : U8x16, U64, U8 -> U8x16
• Num.U8x16.broadcast_lane : U8x16, U64 -> U8x16
• Num.U8x16.interleave_lo : U8x16, U8x16 -> U8x16
• Num.U8x16.interleave_hi : U8x16, U8x16 -> U8x16
• Num.U8x16.even_lanes : U8x16, U8x16 -> U8x16
• Num.U8x16.odd_lanes : U8x16, U8x16 -> U8x16
• Num.U8x16.reverse_lanes : U8x16 -> U8x16
• Num.U8x16.concat_shift_bytes : U8x16, U8x16, U8 -> U8x16
• Num.U8x16.table_lookup : U8x16, U8x16 -> U8x16
• Num.U8x16.to_u16x8_lo : U8x16 -> U16x8
• Num.U8x16.to_u16x8_hi : U8x16 -> U16x8
• Num.U8x16.pairwise_plus_to_u16x8 : U8x16 -> U16x8
• Num.U8x16.times_wide_lo : U8x16, U8x16 -> U16x8
• Num.U8x16.times_wide_hi : U8x16, U8x16 -> U16x8
• Num.U8x16.dot_pairs_saturated : U8x16, I8x16 -> I16x8
• Num.U8x16.sums_of_abs_diffs : U8x16, U8x16 -> U64x2
• Num.U8x16.sum_lanes : U8x16 -> U32
• Num.U8x16.load : List(U8), U64 -> Try(U8x16, [OutOfBounds])
• Num.U8x16.store : U8x16, List(U8), U64 -> Try(List(U8), [OutOfBounds])
• Num.U8x16.append_to : U8x16, List(U8) -> List(U8)
• Num.U8x16.iter_list : List(U8) -> { chunks : Iter(U8x16), tail : List(U8) }
• Num.I8x16
• Num.I8x16.default : () -> I8x16
• Num.I8x16.splat : I8 -> I8x16
• Num.I8x16.from_list : List(I8) -> Try(I8x16, [WrongLength])
• Num.I8x16.to_list : I8x16 -> List(I8)
• Num.I8x16.is_eq : I8x16, I8x16 -> Bool
• Num.I8x16.to_hash : I8x16, Hasher -> Hasher
• Num.I8x16.to_inspect : I8x16 -> Str
• Num.I8x16.to_u128_bits : I8x16 -> U128
• Num.I8x16.from_u128_bits : U128 -> I8x16
• Num.I8x16.to_u8x16_bits : I8x16 -> U8x16
• Num.I8x16.to_u16x8_bits : I8x16 -> U16x8
• Num.I8x16.to_i16x8_bits : I8x16 -> I16x8
• Num.I8x16.to_u32x4_bits : I8x16 -> U32x4
• Num.I8x16.to_i32x4_bits : I8x16 -> I32x4
• Num.I8x16.to_u64x2_bits : I8x16 -> U64x2
• Num.I8x16.to_i64x2_bits : I8x16 -> I64x2
• Num.I8x16.plus_wrap : I8x16, I8x16 -> I8x16
• Num.I8x16.minus_wrap : I8x16, I8x16 -> I8x16
• Num.I8x16.plus_saturated : I8x16, I8x16 -> I8x16
• Num.I8x16.minus_saturated : I8x16, I8x16 -> I8x16
• Num.I8x16.negate_wrap : I8x16 -> I8x16
• Num.I8x16.abs_wrap : I8x16 -> I8x16
• Num.I8x16.min : I8x16, I8x16 -> I8x16
• Num.I8x16.max : I8x16, I8x16 -> I8x16
• Num.I8x16.bitwise_and : I8x16, I8x16 -> I8x16
• Num.I8x16.bitwise_or : I8x16, I8x16 -> I8x16
• Num.I8x16.bitwise_xor : I8x16, I8x16 -> I8x16
• Num.I8x16.bitwise_not : I8x16 -> I8x16
• Num.I8x16.bit_select : I8x16, I8x16, I8x16 -> I8x16
• Num.I8x16.eq_lanes : I8x16, I8x16 -> I8x16
• Num.I8x16.gt_lanes : I8x16, I8x16 -> I8x16
• Num.I8x16.lt_lanes : I8x16, I8x16 -> I8x16
• Num.I8x16.gte_lanes : I8x16, I8x16 -> I8x16
• Num.I8x16.lte_lanes : I8x16, I8x16 -> I8x16
• Num.I8x16.to_bitmask : I8x16 -> U16
• Num.I8x16.any_lanes_set : I8x16 -> Bool
• Num.I8x16.all_lanes_set : I8x16 -> Bool
• Num.I8x16.shl_wrap : I8x16, U8 -> I8x16
• Num.I8x16.shr_zf_wrap : I8x16, U8 -> I8x16
• Num.I8x16.shr_wrap : I8x16, U8 -> I8x16
• Num.I8x16.get_lane : I8x16, U64 -> I8
• Num.I8x16.with_lane : I8x16, U64, I8 -> I8x16
• Num.I8x16.broadcast_lane : I8x16, U64 -> I8x16
• Num.I8x16.interleave_lo : I8x16, I8x16 -> I8x16
• Num.I8x16.interleave_hi : I8x16, I8x16 -> I8x16
• Num.I8x16.even_lanes : I8x16, I8x16 -> I8x16
• Num.I8x16.odd_lanes : I8x16, I8x16 -> I8x16
• Num.I8x16.reverse_lanes : I8x16 -> I8x16
• Num.I8x16.to_i16x8_lo : I8x16 -> I16x8
• Num.I8x16.to_i16x8_hi : I8x16 -> I16x8
• Num.I8x16.pairwise_plus_to_i16x8 : I8x16 -> I16x8
• Num.I8x16.times_wide_lo : I8x16, I8x16 -> I16x8
• Num.I8x16.times_wide_hi : I8x16, I8x16 -> I16x8
• Num.I8x16.sum_lanes : I8x16 -> I32
• Num.I8x16.load : List(U8), U64 -> Try(I8x16, [OutOfBounds])
• Num.I8x16.store : I8x16, List(U8), U64 -> Try(List(U8), [OutOfBounds])
• Num.I8x16.append_to : I8x16, List(U8) -> List(U8)
• Num.U16x8
• Num.U16x8.default : () -> U16x8
• Num.U16x8.splat : U16 -> U16x8
• Num.U16x8.from_list : List(U16) -> Try(U16x8, [WrongLength])
• Num.U16x8.to_list : U16x8 -> List(U16)
• Num.U16x8.is_eq : U16x8, U16x8 -> Bool
• Num.U16x8.to_hash : U16x8, Hasher -> Hasher
• Num.U16x8.to_inspect : U16x8 -> Str
• Num.U16x8.to_u128_bits : U16x8 -> U128
• Num.U16x8.from_u128_bits : U128 -> U16x8
• Num.U16x8.to_u8x16_bits : U16x8 -> U8x16
• Num.U16x8.to_i8x16_bits : U16x8 -> I8x16
• Num.U16x8.to_i16x8_bits : U16x8 -> I16x8
• Num.U16x8.to_u32x4_bits : U16x8 -> U32x4
• Num.U16x8.to_i32x4_bits : U16x8 -> I32x4
• Num.U16x8.to_u64x2_bits : U16x8 -> U64x2
• Num.U16x8.to_i64x2_bits : U16x8 -> I64x2
• Num.U16x8.plus_wrap : U16x8, U16x8 -> U16x8
• Num.U16x8.minus_wrap : U16x8, U16x8 -> U16x8
• Num.U16x8.plus_saturated : U16x8, U16x8 -> U16x8
• Num.U16x8.minus_saturated : U16x8, U16x8 -> U16x8
• Num.U16x8.min : U16x8, U16x8 -> U16x8
• Num.U16x8.max : U16x8, U16x8 -> U16x8
• Num.U16x8.abs_diff : U16x8, U16x8 -> U16x8
• Num.U16x8.avg_rounded : U16x8, U16x8 -> U16x8
• Num.U16x8.times_wrap : U16x8, U16x8 -> U16x8
• Num.U16x8.times_high : U16x8, U16x8 -> U16x8
• Num.U16x8.bitwise_and : U16x8, U16x8 -> U16x8
• Num.U16x8.bitwise_or : U16x8, U16x8 -> U16x8
• Num.U16x8.bitwise_xor : U16x8, U16x8 -> U16x8
• Num.U16x8.bitwise_not : U16x8 -> U16x8
• Num.U16x8.bit_select : U16x8, U16x8, U16x8 -> U16x8
• Num.U16x8.eq_lanes : U16x8, U16x8 -> U16x8
• Num.U16x8.gt_lanes : U16x8, U16x8 -> U16x8
• Num.U16x8.lt_lanes : U16x8, U16x8 -> U16x8
• Num.U16x8.gte_lanes : U16x8, U16x8 -> U16x8
• Num.U16x8.lte_lanes : U16x8, U16x8 -> U16x8
• Num.U16x8.to_bitmask : U16x8 -> U8
• Num.U16x8.any_lanes_set : U16x8 -> Bool
• Num.U16x8.all_lanes_set : U16x8 -> Bool
• Num.U16x8.shl_wrap : U16x8, U8 -> U16x8
• Num.U16x8.shr_wrap : U16x8, U8 -> U16x8
• Num.U16x8.shr_zf_wrap : U16x8, U8 -> U16x8
• Num.U16x8.get_lane : U16x8, U64 -> U16
• Num.U16x8.with_lane : U16x8, U64, U16 -> U16x8
• Num.U16x8.broadcast_lane : U16x8, U64 -> U16x8
• Num.U16x8.interleave_lo : U16x8, U16x8 -> U16x8
• Num.U16x8.interleave_hi : U16x8, U16x8 -> U16x8
• Num.U16x8.even_lanes : U16x8, U16x8 -> U16x8
• Num.U16x8.odd_lanes : U16x8, U16x8 -> U16x8
• Num.U16x8.reverse_lanes : U16x8 -> U16x8
• Num.U16x8.to_u32x4_lo : U16x8 -> U32x4
• Num.U16x8.to_u32x4_hi : U16x8 -> U32x4
• Num.U16x8.pairwise_plus_to_u32x4 : U16x8 -> U32x4
• Num.U16x8.times_wide_lo : U16x8, U16x8 -> U32x4
• Num.U16x8.times_wide_hi : U16x8, U16x8 -> U32x4
• Num.U16x8.narrow_to_u8x16_wrap : U16x8, U16x8 -> U8x16
• Num.U16x8.narrow_to_u8x16_saturated : U16x8, U16x8 -> U8x16
• Num.U16x8.sum_lanes : U16x8 -> U32
• Num.U16x8.load : List(U8), U64 -> Try(U16x8, [OutOfBounds])
• Num.U16x8.load_units : List(U16), U64 -> Try(U16x8, [OutOfBounds])
• Num.U16x8.store : U16x8, List(U8), U64 -> Try(List(U8), [OutOfBounds])
• Num.U16x8.append_to : U16x8, List(U8) -> List(U8)
• Num.I16x8
• Num.I16x8.default : () -> I16x8
• Num.I16x8.splat : I16 -> I16x8
• Num.I16x8.from_list : List(I16) -> Try(I16x8, [WrongLength])
• Num.I16x8.to_list : I16x8 -> List(I16)
• Num.I16x8.is_eq : I16x8, I16x8 -> Bool
• Num.I16x8.to_hash : I16x8, Hasher -> Hasher
• Num.I16x8.to_inspect : I16x8 -> Str
• Num.I16x8.to_u128_bits : I16x8 -> U128
• Num.I16x8.from_u128_bits : U128 -> I16x8
• Num.I16x8.to_u8x16_bits : I16x8 -> U8x16
• Num.I16x8.to_i8x16_bits : I16x8 -> I8x16
• Num.I16x8.to_u16x8_bits : I16x8 -> U16x8
• Num.I16x8.to_u32x4_bits : I16x8 -> U32x4
• Num.I16x8.to_i32x4_bits : I16x8 -> I32x4
• Num.I16x8.to_u64x2_bits : I16x8 -> U64x2
• Num.I16x8.to_i64x2_bits : I16x8 -> I64x2
• Num.I16x8.plus_wrap : I16x8, I16x8 -> I16x8
• Num.I16x8.minus_wrap : I16x8, I16x8 -> I16x8
• Num.I16x8.plus_saturated : I16x8, I16x8 -> I16x8
• Num.I16x8.minus_saturated : I16x8, I16x8 -> I16x8
• Num.I16x8.negate_wrap : I16x8 -> I16x8
• Num.I16x8.abs_wrap : I16x8 -> I16x8
• Num.I16x8.min : I16x8, I16x8 -> I16x8
• Num.I16x8.max : I16x8, I16x8 -> I16x8
• Num.I16x8.times_wrap : I16x8, I16x8 -> I16x8
• Num.I16x8.times_high : I16x8, I16x8 -> I16x8
• Num.I16x8.times_fixed_q15_saturated : I16x8, I16x8 -> I16x8
• Num.I16x8.dot_pairs : I16x8, I16x8 -> I32x4
• Num.I16x8.bitwise_and : I16x8, I16x8 -> I16x8
• Num.I16x8.bitwise_or : I16x8, I16x8 -> I16x8
• Num.I16x8.bitwise_xor : I16x8, I16x8 -> I16x8
• Num.I16x8.bitwise_not : I16x8 -> I16x8
• Num.I16x8.bit_select : I16x8, I16x8, I16x8 -> I16x8
• Num.I16x8.eq_lanes : I16x8, I16x8 -> I16x8
• Num.I16x8.gt_lanes : I16x8, I16x8 -> I16x8
• Num.I16x8.lt_lanes : I16x8, I16x8 -> I16x8
• Num.I16x8.gte_lanes : I16x8, I16x8 -> I16x8
• Num.I16x8.lte_lanes : I16x8, I16x8 -> I16x8
• Num.I16x8.to_bitmask : I16x8 -> U8
• Num.I16x8.any_lanes_set : I16x8 -> Bool
• Num.I16x8.all_lanes_set : I16x8 -> Bool
• Num.I16x8.shl_wrap : I16x8, U8 -> I16x8
• Num.I16x8.shr_wrap : I16x8, U8 -> I16x8
• Num.I16x8.shr_zf_wrap : I16x8, U8 -> I16x8
• Num.I16x8.shift_right_rounded_by : I16x8, U8 -> I16x8
• Num.I16x8.narrow_to_i8x16_saturated : I16x8, I16x8 -> I8x16
• Num.I16x8.narrow_to_u8x16_saturated : I16x8, I16x8 -> U8x16
• Num.I16x8.to_i32x4_lo : I16x8 -> I32x4
• Num.I16x8.to_i32x4_hi : I16x8 -> I32x4
• Num.I16x8.pairwise_plus_to_i32x4 : I16x8 -> I32x4
• Num.I16x8.times_wide_lo : I16x8, I16x8 -> I32x4
• Num.I16x8.times_wide_hi : I16x8, I16x8 -> I32x4
• Num.I16x8.sum_lanes : I16x8 -> I32
• Num.I16x8.get_lane : I16x8, U64 -> I16
• Num.I16x8.with_lane : I16x8, U64, I16 -> I16x8
• Num.I16x8.broadcast_lane : I16x8, U64 -> I16x8
• Num.I16x8.interleave_lo : I16x8, I16x8 -> I16x8
• Num.I16x8.interleave_hi : I16x8, I16x8 -> I16x8
• Num.I16x8.even_lanes : I16x8, I16x8 -> I16x8
• Num.I16x8.odd_lanes : I16x8, I16x8 -> I16x8
• Num.I16x8.reverse_lanes : I16x8 -> I16x8
• Num.I16x8.load : List(U8), U64 -> Try(I16x8, [OutOfBounds])
• Num.I16x8.store : I16x8, List(U8), U64 -> Try(List(U8), [OutOfBounds])
• Num.I16x8.append_to : I16x8, List(U8) -> List(U8)
• Num.U32x4
• Num.U32x4.default : () -> U32x4
• Num.U32x4.splat : U32 -> U32x4
• Num.U32x4.from_list : List(U32) -> Try(U32x4, [WrongLength])
• Num.U32x4.to_list : U32x4 -> List(U32)
• Num.U32x4.is_eq : U32x4, U32x4 -> Bool
• Num.U32x4.to_hash : U32x4, Hasher -> Hasher
• Num.U32x4.to_inspect : U32x4 -> Str
• Num.U32x4.to_u128_bits : U32x4 -> U128
• Num.U32x4.from_u128_bits : U128 -> U32x4
• Num.U32x4.to_u8x16_bits : U32x4 -> U8x16
• Num.U32x4.to_i8x16_bits : U32x4 -> I8x16
• Num.U32x4.to_u16x8_bits : U32x4 -> U16x8
• Num.U32x4.to_i16x8_bits : U32x4 -> I16x8
• Num.U32x4.to_i32x4_bits : U32x4 -> I32x4
• Num.U32x4.to_u64x2_bits : U32x4 -> U64x2
• Num.U32x4.to_i64x2_bits : U32x4 -> I64x2
• Num.U32x4.plus_wrap : U32x4, U32x4 -> U32x4
• Num.U32x4.minus_wrap : U32x4, U32x4 -> U32x4
• Num.U32x4.min : U32x4, U32x4 -> U32x4
• Num.U32x4.max : U32x4, U32x4 -> U32x4
• Num.U32x4.times_wrap : U32x4, U32x4 -> U32x4
• Num.U32x4.times_wide_lo : U32x4, U32x4 -> U64x2
• Num.U32x4.times_wide_hi : U32x4, U32x4 -> U64x2
• Num.U32x4.bitwise_and : U32x4, U32x4 -> U32x4
• Num.U32x4.bitwise_or : U32x4, U32x4 -> U32x4
• Num.U32x4.bitwise_xor : U32x4, U32x4 -> U32x4
• Num.U32x4.bitwise_not : U32x4 -> U32x4
• Num.U32x4.bit_select : U32x4, U32x4, U32x4 -> U32x4
• Num.U32x4.eq_lanes : U32x4, U32x4 -> U32x4
• Num.U32x4.gt_lanes : U32x4, U32x4 -> U32x4
• Num.U32x4.lt_lanes : U32x4, U32x4 -> U32x4
• Num.U32x4.gte_lanes : U32x4, U32x4 -> U32x4
• Num.U32x4.lte_lanes : U32x4, U32x4 -> U32x4
• Num.U32x4.to_bitmask : U32x4 -> U8
• Num.U32x4.any_lanes_set : U32x4 -> Bool
• Num.U32x4.all_lanes_set : U32x4 -> Bool
• Num.U32x4.shl_wrap : U32x4, U8 -> U32x4
• Num.U32x4.shr_wrap : U32x4, U8 -> U32x4
• Num.U32x4.shr_zf_wrap : U32x4, U8 -> U32x4
• Num.U32x4.get_lane : U32x4, U64 -> U32
• Num.U32x4.with_lane : U32x4, U64, U32 -> U32x4
• Num.U32x4.broadcast_lane : U32x4, U64 -> U32x4
• Num.U32x4.interleave_lo : U32x4, U32x4 -> U32x4
• Num.U32x4.interleave_hi : U32x4, U32x4 -> U32x4
• Num.U32x4.even_lanes : U32x4, U32x4 -> U32x4
• Num.U32x4.odd_lanes : U32x4, U32x4 -> U32x4
• Num.U32x4.reverse_lanes : U32x4 -> U32x4
• Num.U32x4.to_u64x2_lo : U32x4 -> U64x2
• Num.U32x4.to_u64x2_hi : U32x4 -> U64x2
• Num.U32x4.narrow_to_u16x8_wrap : U32x4, U32x4 -> U16x8
• Num.U32x4.narrow_to_u16x8_saturated : U32x4, U32x4 -> U16x8
• Num.U32x4.sum_lanes : U32x4 -> U64
• Num.U32x4.load : List(U8), U64 -> Try(U32x4, [OutOfBounds])
• Num.U32x4.load_units : List(U32), U64 -> Try(U32x4, [OutOfBounds])
• Num.U32x4.store : U32x4, List(U8), U64 -> Try(List(U8), [OutOfBounds])
• Num.U32x4.append_to : U32x4, List(U8) -> List(U8)
• Num.I32x4
• Num.I32x4.default : () -> I32x4
• Num.I32x4.splat : I32 -> I32x4
• Num.I32x4.from_list : List(I32) -> Try(I32x4, [WrongLength])
• Num.I32x4.to_list : I32x4 -> List(I32)
• Num.I32x4.is_eq : I32x4, I32x4 -> Bool
• Num.I32x4.to_hash : I32x4, Hasher -> Hasher
• Num.I32x4.to_inspect : I32x4 -> Str
• Num.I32x4.to_u128_bits : I32x4 -> U128
• Num.I32x4.from_u128_bits : U128 -> I32x4
• Num.I32x4.to_u8x16_bits : I32x4 -> U8x16
• Num.I32x4.to_i8x16_bits : I32x4 -> I8x16
• Num.I32x4.to_u16x8_bits : I32x4 -> U16x8
• Num.I32x4.to_i16x8_bits : I32x4 -> I16x8
• Num.I32x4.to_u32x4_bits : I32x4 -> U32x4
• Num.I32x4.to_u64x2_bits : I32x4 -> U64x2
• Num.I32x4.to_i64x2_bits : I32x4 -> I64x2
• Num.I32x4.plus_wrap : I32x4, I32x4 -> I32x4
• Num.I32x4.minus_wrap : I32x4, I32x4 -> I32x4
• Num.I32x4.negate_wrap : I32x4 -> I32x4
• Num.I32x4.abs_wrap : I32x4 -> I32x4
• Num.I32x4.min : I32x4, I32x4 -> I32x4
• Num.I32x4.max : I32x4, I32x4 -> I32x4
• Num.I32x4.times_wrap : I32x4, I32x4 -> I32x4
• Num.I32x4.times_wide_lo : I32x4, I32x4 -> I64x2
• Num.I32x4.times_wide_hi : I32x4, I32x4 -> I64x2
• Num.I32x4.bitwise_and : I32x4, I32x4 -> I32x4
• Num.I32x4.bitwise_or : I32x4, I32x4 -> I32x4
• Num.I32x4.bitwise_xor : I32x4, I32x4 -> I32x4
• Num.I32x4.bitwise_not : I32x4 -> I32x4
• Num.I32x4.bit_select : I32x4, I32x4, I32x4 -> I32x4
• Num.I32x4.eq_lanes : I32x4, I32x4 -> I32x4
• Num.I32x4.gt_lanes : I32x4, I32x4 -> I32x4
• Num.I32x4.lt_lanes : I32x4, I32x4 -> I32x4
• Num.I32x4.gte_lanes : I32x4, I32x4 -> I32x4
• Num.I32x4.lte_lanes : I32x4, I32x4 -> I32x4
• Num.I32x4.to_bitmask : I32x4 -> U8
• Num.I32x4.any_lanes_set : I32x4 -> Bool
• Num.I32x4.all_lanes_set : I32x4 -> Bool
• Num.I32x4.shl_wrap : I32x4, U8 -> I32x4
• Num.I32x4.shr_wrap : I32x4, U8 -> I32x4
• Num.I32x4.shr_zf_wrap : I32x4, U8 -> I32x4
• Num.I32x4.shift_right_rounded_by : I32x4, U8 -> I32x4
• Num.I32x4.narrow_to_i16x8_saturated : I32x4, I32x4 -> I16x8
• Num.I32x4.narrow_to_u16x8_saturated : I32x4, I32x4 -> U16x8
• Num.I32x4.to_i64x2_lo : I32x4 -> I64x2
• Num.I32x4.to_i64x2_hi : I32x4 -> I64x2
• Num.I32x4.sum_lanes : I32x4 -> I64
• Num.I32x4.get_lane : I32x4, U64 -> I32
• Num.I32x4.with_lane : I32x4, U64, I32 -> I32x4
• Num.I32x4.broadcast_lane : I32x4, U64 -> I32x4
• Num.I32x4.interleave_lo : I32x4, I32x4 -> I32x4
• Num.I32x4.interleave_hi : I32x4, I32x4 -> I32x4
• Num.I32x4.even_lanes : I32x4, I32x4 -> I32x4
• Num.I32x4.odd_lanes : I32x4, I32x4 -> I32x4
• Num.I32x4.reverse_lanes : I32x4 -> I32x4
• Num.I32x4.load : List(U8), U64 -> Try(I32x4, [OutOfBounds])
• Num.I32x4.store : I32x4, List(U8), U64 -> Try(List(U8), [OutOfBounds])
• Num.I32x4.append_to : I32x4, List(U8) -> List(U8)
• Num.U64x2
• Num.U64x2.default : () -> U64x2
• Num.U64x2.splat : U64 -> U64x2
• Num.U64x2.from_list : List(U64) -> Try(U64x2, [WrongLength])
• Num.U64x2.to_list : U64x2 -> List(U64)
• Num.U64x2.is_eq : U64x2, U64x2 -> Bool
• Num.U64x2.to_hash : U64x2, Hasher -> Hasher
• Num.U64x2.to_inspect : U64x2 -> Str
• Num.U64x2.to_u128_bits : U64x2 -> U128
• Num.U64x2.from_u128_bits : U128 -> U64x2
• Num.U64x2.to_u8x16_bits : U64x2 -> U8x16
• Num.U64x2.to_i8x16_bits : U64x2 -> I8x16
• Num.U64x2.to_u16x8_bits : U64x2 -> U16x8
• Num.U64x2.to_i16x8_bits : U64x2 -> I16x8
• Num.U64x2.to_u32x4_bits : U64x2 -> U32x4
• Num.U64x2.to_i32x4_bits : U64x2 -> I32x4
• Num.U64x2.to_i64x2_bits : U64x2 -> I64x2
• Num.U64x2.plus_wrap : U64x2, U64x2 -> U64x2
• Num.U64x2.minus_wrap : U64x2, U64x2 -> U64x2
• Num.U64x2.bitwise_and : U64x2, U64x2 -> U64x2
• Num.U64x2.bitwise_or : U64x2, U64x2 -> U64x2
• Num.U64x2.bitwise_xor : U64x2, U64x2 -> U64x2
• Num.U64x2.bitwise_not : U64x2 -> U64x2
• Num.U64x2.bit_select : U64x2, U64x2, U64x2 -> U64x2
• Num.U64x2.eq_lanes : U64x2, U64x2 -> U64x2
• Num.U64x2.to_bitmask : U64x2 -> U8
• Num.U64x2.any_lanes_set : U64x2 -> Bool
• Num.U64x2.all_lanes_set : U64x2 -> Bool
• Num.U64x2.shl_wrap : U64x2, U8 -> U64x2
• Num.U64x2.shr_wrap : U64x2, U8 -> U64x2
• Num.U64x2.shr_zf_wrap : U64x2, U8 -> U64x2
• Num.U64x2.get_lane : U64x2, U64 -> U64
• Num.U64x2.with_lane : U64x2, U64, U64 -> U64x2
• Num.U64x2.broadcast_lane : U64x2, U64 -> U64x2
• Num.U64x2.interleave_lo : U64x2, U64x2 -> U64x2
• Num.U64x2.interleave_hi : U64x2, U64x2 -> U64x2
• Num.U64x2.reverse_lanes : U64x2 -> U64x2
• Num.U64x2.narrow_to_u32x4_wrap : U64x2, U64x2 -> U32x4
• Num.U64x2.sum_lanes_wrap : U64x2 -> U64
• Num.U64x2.carryless_times_lo : U64x2, U64x2 -> U64x2
• Num.U64x2.carryless_times_hi : U64x2, U64x2 -> U64x2
• Num.U64x2.load : List(U8), U64 -> Try(U64x2, [OutOfBounds])
• Num.U64x2.store : U64x2, List(U8), U64 -> Try(List(U8), [OutOfBounds])
• Num.U64x2.append_to : U64x2, List(U8) -> List(U8)
• Num.I64x2
• Num.I64x2.default : () -> I64x2
• Num.I64x2.splat : I64 -> I64x2
• Num.I64x2.from_list : List(I64) -> Try(I64x2, [WrongLength])
• Num.I64x2.to_list : I64x2 -> List(I64)
• Num.I64x2.is_eq : I64x2, I64x2 -> Bool
• Num.I64x2.to_hash : I64x2, Hasher -> Hasher
• Num.I64x2.to_inspect : I64x2 -> Str
• Num.I64x2.to_u128_bits : I64x2 -> U128
• Num.I64x2.from_u128_bits : U128 -> I64x2
• Num.I64x2.to_u8x16_bits : I64x2 -> U8x16
• Num.I64x2.to_i8x16_bits : I64x2 -> I8x16
• Num.I64x2.to_u16x8_bits : I64x2 -> U16x8
• Num.I64x2.to_i16x8_bits : I64x2 -> I16x8
• Num.I64x2.to_u32x4_bits : I64x2 -> U32x4
• Num.I64x2.to_i32x4_bits : I64x2 -> I32x4
• Num.I64x2.to_u64x2_bits : I64x2 -> U64x2
• Num.I64x2.plus_wrap : I64x2, I64x2 -> I64x2
• Num.I64x2.minus_wrap : I64x2, I64x2 -> I64x2
• Num.I64x2.negate_wrap : I64x2 -> I64x2
• Num.I64x2.bitwise_and : I64x2, I64x2 -> I64x2
• Num.I64x2.bitwise_or : I64x2, I64x2 -> I64x2
• Num.I64x2.bitwise_xor : I64x2, I64x2 -> I64x2
• Num.I64x2.bitwise_not : I64x2 -> I64x2
• Num.I64x2.bit_select : I64x2, I64x2, I64x2 -> I64x2
• Num.I64x2.eq_lanes : I64x2, I64x2 -> I64x2
• Num.I64x2.gt_lanes : I64x2, I64x2 -> I64x2
• Num.I64x2.lt_lanes : I64x2, I64x2 -> I64x2
• Num.I64x2.gte_lanes : I64x2, I64x2 -> I64x2
• Num.I64x2.lte_lanes : I64x2, I64x2 -> I64x2
• Num.I64x2.to_bitmask : I64x2 -> U8
• Num.I64x2.any_lanes_set : I64x2 -> Bool
• Num.I64x2.all_lanes_set : I64x2 -> Bool
• Num.I64x2.shl_wrap : I64x2, U8 -> I64x2
• Num.I64x2.shr_wrap : I64x2, U8 -> I64x2
• Num.I64x2.shr_zf_wrap : I64x2, U8 -> I64x2
• Num.I64x2.get_lane : I64x2, U64 -> I64
• Num.I64x2.with_lane : I64x2, U64, I64 -> I64x2
• Num.I64x2.broadcast_lane : I64x2, U64 -> I64x2
• Num.I64x2.interleave_lo : I64x2, I64x2 -> I64x2
• Num.I64x2.interleave_hi : I64x2, I64x2 -> I64x2
• Num.I64x2.reverse_lanes : I64x2 -> I64x2
• Num.I64x2.sum_lanes_wrap : I64x2 -> I64
• Num.I64x2.load : List(U8), U64 -> Try(I64x2, [OutOfBounds])
• Num.I64x2.store : I64x2, List(U8), U64 -> Try(List(U8), [OutOfBounds])
• Num.I64x2.append_to : I64x2, List(U8) -> List(U8)
• Set
• Set.parser_for : _
• Set.encoder_for : _
• Set.is_eq : Set(a), Set(a) -> Bool where [a.is_eq : a, a -> Bool, a.to_hash : a, Hasher -> Hasher]
• Set.to_hash : Set(a), Hasher -> Hasher where [a.to_hash : a, Hasher -> Hasher]
• Set.to_inspect : Set(a) -> Str
• Set.empty : () -> Set(_item)
• Set.single : item -> Set(item) where [item.is_eq : item, item -> Bool, item.to_hash : item, Hasher -> Hasher]
• Set.len : Set(_item) -> U64
• Set.is_empty : Set(_item) -> Bool
• Set.contains : Set(a), a -> Bool where [a.is_eq : a, a -> Bool, a.to_hash : a, Hasher -> Hasher]
• Set.insert : Set(a), a -> Set(a) where [a.is_eq : a, a -> Bool, a.to_hash : a, Hasher -> Hasher]
• Set.remove : Set(a), a -> Set(a) where [a.is_eq : a, a -> Bool, a.to_hash : a, Hasher -> Hasher]
• Set.to_list : Set(a) -> List(a)
• Set.fold : Set(a), state, (state, a -> state) -> state
• Set.iter : Set(a) -> Iter(a)
• Set.iter_rev : Set(a) -> Iter(a)
• Set.from_list : List(a) -> Set(a) where [a.is_eq : a, a -> Bool, a.to_hash : a, Hasher -> Hasher]
• Set.keep_if : Set(a), (a -> Bool) -> Set(a) where [a.to_hash : a, Hasher -> Hasher]
• Set.drop_if : Set(a), (a -> Bool) -> Set(a) where [a.to_hash : a, Hasher -> Hasher]
• Set.union : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool, a.to_hash : a, Hasher -> Hasher]
• Set.intersection : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool, a.to_hash : a, Hasher -> Hasher]
• Set.difference : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool, a.to_hash : a, Hasher -> Hasher]
• Set.map : Set(a), (a -> b) -> Set(b) where [b.is_eq : b, b -> Bool, b.to_hash : b, Hasher -> Hasher]
• Set.with_capacity : U64 -> Set(_item)
• Set.capacity : Set(_item) -> U64
• Set.reserve : Set(item), U64 -> Set(item) where [item.to_hash : item, Hasher -> Hasher]
• Set.release_excess_capacity : Set(item) -> Set(item) where [item.to_hash : item, Hasher -> Hasher]
• Set.clear : Set(item) -> Set(item)
• Set.subscript : Set(item), item -> Bool where [item.is_eq : item, item -> Bool, item.to_hash : item, Hasher -> Hasher]
• Set.from_iter : Iter(item) -> Set(item) where [item.is_eq : item, item -> Bool, item.to_hash : item, Hasher -> Hasher]
• Set.fold_until : Set(item), state, (state, item -> [Continue(state), Break(state)]) -> state
• Set.join_map : Set(a), (a -> Set(b)) -> Set(b) where [b.is_eq : b, b -> Bool, b.to_hash : b, Hasher -> Hasher]
• Sort
• Str
• Str.parser_for : _
• Str.encoder_for : _
• Str.len : Str -> [LearnAboutStringsInRoc(Str)]
• 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.split_first : Str, Str -> Try({ before : Str, after : Str }, [NotFound])
• Str.split_last : Str, Str -> Try({ before : Str, after : Str }, [NotFound])
• Str.replace_each : Str, Str, Str -> Str
• Str.replace_first : Str, Str, Str -> Str
• Str.replace_last : Str, Str, Str -> Str
• Str.count_utf8_bytes : Str -> U64
• Str.iter_utf8 : Str -> Iter(U8)
• Str.drop_first_bytes : Str, U64 -> Try(Str, [BadUtf8])
• Str.drop_last_bytes : Str, U64 -> Try(Str, [BadUtf8])
• Str.with_capacity : U64 -> Str
• Str.reserve : Str, U64 -> Str
• Str.release_excess_capacity : Str -> Str
• Str.to_utf8 : Str -> List(U8)
• Str.to_str : Str -> Str
• Str.from_utf8_lossy : List(U8) -> Str
• Str.from_utf8 : List(U8) -> Try(Str, [BadUtf8({ problem : Utf8Problem, index : U64 })])
• Str.from_utf16_le : List(U8) -> Try(Str, [BadUtf16({ problem : Utf16Problem, index : U64 })])
• Str.from_utf16_le_lossy : List(U8) -> Str
• Str.from_utf16_be : List(U8) -> Try(Str, [BadUtf16({ problem : Utf16Problem, index : U64 })])
• Str.from_utf16_be_lossy : List(U8) -> Str
• Str.from_utf16_bom : List(U8) -> Try(Str, [BadUtf16({ problem : Utf16Problem, index : U64 }), MissingByteOrderMark])
• Str.from_utf16_bom_lossy : List(U8) -> Try(Str, [MissingByteOrderMark])
• Str.from_utf32_le : List(U8) -> Try(Str, [BadUtf32({ problem : Utf32Problem, index : U64 })])
• Str.from_utf32_le_lossy : List(U8) -> Str
• Str.from_utf32_be : List(U8) -> Try(Str, [BadUtf32({ problem : Utf32Problem, index : U64 })])
• Str.from_utf32_be_lossy : List(U8) -> Str
• Str.from_utf32_bom : List(U8) -> Try(Str, [BadUtf32({ problem : Utf32Problem, index : U64 }), MissingByteOrderMark])
• Str.from_utf32_bom_lossy : List(U8) -> Try(Str, [MissingByteOrderMark])
• Str.from_quote : Str -> Try(Str, [BadQuotedBytes(Str)])
• Str.from_interpolation : List(Str) -> Try(List(Str) -> Str, [InvalidInterpolation(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
• Str.Utf16Problem := [UnpairedHighSurrogate, UnpairedLowSurrogate, UnexpectedEndOfSequence]
• Str.Utf16Problem.is_eq : Utf16Problem, Utf16Problem -> Bool
• Str.Utf32Problem := [CodePointTooLarge, SurrogateCodePoint, UnexpectedEndOfSequence]
• Str.Utf32Problem.is_eq : Utf32Problem, Utf32Problem -> Bool
• Stream
• Stream.from_iter : Iter(item) -> Stream(item)
• Stream.custom : state, [Known(U64), Unknown], (state => Try((item, state), [NoMore])) -> Stream(item)
• Stream.map : Stream(a), (a => b) -> Stream(b)
• Stream.map! : Stream(a), (a => b) => Stream(b)
• Stream.with_index : Stream(a) -> Stream((U64, a))
• Stream.keep_if : Stream(a), (a => Bool) -> Stream(a)
• Stream.drop_if : Stream(a), (a => Bool) -> Stream(a)
• Stream.take_first : Stream(item), U64 -> Stream(item)
• Stream.drop_first : Stream(item), U64 -> Stream(item)
• Stream.stream : Stream(item) -> Stream(item)
• Stream.fold! : Stream(a), acc, (acc, a => acc) => acc
• Stream.for_each! : Stream(a), (a => {}) => {}
• 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
• Try.parser_for : _
• Try.encoder_for : _
• Try.is_ok : Try(_ok, _err) -> Bool
• Try.is_err : Try(_ok, _err) -> Bool
• Try.ok_or : Try(ok, _err), ok -> ok
• Try.err_or : Try(_ok, err), err -> err
• Try.map_ok : Try(a, err), (a -> b) -> Try(b, err)
• Try.map_ok! : Try(a, err), (a => b) => Try(b, err)
• Try.map_err : Try(ok, a), (a -> b) -> Try(ok, b)
• Try.map_err! : Try(ok, a), (a => b) => Try(ok, b)
• Try.map_both : Try(a, b), (a -> c), (b -> d) -> Try(c, d)
• Try.map_both! : Try(a, b), (a => c), (b => d) => Try(c, d)
• Try.map2 : Try(a, err), Try(b, err), (a, b -> c) -> Try(c, err)
• Try.map2! : Try(a, err), Try(b, err), (a, b => c) => Try(c, err)
• Try.on_err : Try(ok, a), (a -> Try(ok, b)) -> Try(ok, b)
• Try.on_err! : Try(ok, a), (a => Try(ok, b)) => Try(ok, b)
• Try.catch : Try(ok, err), (err -> a), (ok -> a) -> a
• Try.catch! : Try(ok, err), (err => a), (ok => a) => a
• Try.collapse : Try(a, a) -> a
• Try.is_eq : Try(ok, err), Try(ok, err) -> Bool where [ok.is_eq : ok, ok -> Bool, err.is_eq : err, err -> Bool]
• Try.to_hash : Try(ok, err), Hasher -> Hasher where [ok.to_hash : ok, Hasher -> Hasher, err.to_hash : err, Hasher -> Hasher]

• Language Reference
• Examples
• Tutorial
• FAQ

Hasher

Builtin.Hasher :: # (opaque)

write_bool : Hasher, Bool -> Hasher

Feed a Bool into the hasher.

write_u8 : Hasher, U8 -> Hasher

Feed a U8 into the hasher.

write_u16 : Hasher, U16 -> Hasher

Feed a U16 into the hasher.

write_u32 : Hasher, U32 -> Hasher

Feed a U32 into the hasher.

write_u64 : Hasher, U64 -> Hasher

Feed a U64 into the hasher.

write_u128 : Hasher, U128 -> Hasher

Feed a U128 into the hasher.

write_i8 : Hasher, I8 -> Hasher

Feed an I8 into the hasher.

write_i16 : Hasher, I16 -> Hasher

Feed an I16 into the hasher.

write_i32 : Hasher, I32 -> Hasher

Feed an I32 into the hasher.

write_i64 : Hasher, I64 -> Hasher

Feed an I64 into the hasher.

write_i128 : Hasher, I128 -> Hasher

Feed an I128 into the hasher.

write_f32 : Hasher, F32 -> Hasher

Feed an F32 into the hasher. Positive and negative zero hash identically, and every NaN representation hashes identically.

write_f64 : Hasher, F64 -> Hasher

Feed an F64 into the hasher. Positive and negative zero hash identically, and every NaN representation hashes identically.

write_dec : Hasher, Dec -> Hasher

Feed a Dec into the hasher.

write_bytes : Hasher, List(U8) -> Hasher

Feed bytes into the hasher.

write_str : Hasher, Str -> Hasher

Feed a string into the hasher.