Documentation

Tutorial
FAQ
Builtin Types
Language Reference

Tip: Some names differ from other languages.

Bool.not : Bool -> Bool
Bool.is_eq : Bool, Bool -> Bool
Bool.to_hash : Bool, Hasher -> Hasher
Bool.encode : Bool, fmt -> Try(encoded, err) where [fmt.encode_bool : fmt, Bool -> Try(encoded, err)]
Bool.decode : src, fmt -> (Try(Bool, err), src) where [fmt.decode_bool : fmt, src -> (Try(Bool, err), src)]
Box.box : item -> Box(item)
Box.unbox : Box(item) -> item
Crypto.DigestBytesErr := [WrongLength({ expected : U64, actual : U64 })]
Crypto.DigestHexErr := [WrongLength({ expected : U64, actual : U64 }), InvalidHex({ index : U64, byte : U8 })]
Crypto.SHA256
Crypto.SHA256.hash : List(U8) -> Digest
Crypto.SHA256.hash_chunks : Iter(List(U8)) -> Digest
Crypto.SHA256.Digest
Crypto.SHA256.Digest.to_bytes : Digest -> List(U8)
Crypto.SHA256.Digest.to_hex : Digest -> Str
Crypto.SHA256.Digest.from_bytes : List(U8) -> Try(Digest, DigestBytesErr)
Crypto.SHA256.Digest.from_hex : Str -> Try(Digest, DigestHexErr)
Crypto.SHA256.Digest.is_eq : Digest, Digest -> Bool
Crypto.SHA256.Digest.to_hash : Digest, Hasher -> Hasher
Crypto.SHA256.Digest.to_inspect : Digest -> Str
Crypto.SHA256.Hasher
Crypto.SHA256.Hasher.empty : -> Hasher
Crypto.SHA256.Hasher.write : Hasher, List(U8) -> Hasher
Crypto.SHA256.Hasher.finish : Hasher -> Digest
Crypto.BLAKE3
Crypto.BLAKE3.hash : List(U8) -> Digest
Crypto.BLAKE3.hash_chunks : Iter(List(U8)) -> Digest
Crypto.BLAKE3.Digest
Crypto.BLAKE3.Digest.to_bytes : Digest -> List(U8)
Crypto.BLAKE3.Digest.to_hex : Digest -> Str
Crypto.BLAKE3.Digest.from_bytes : List(U8) -> Try(Digest, DigestBytesErr)
Crypto.BLAKE3.Digest.from_hex : Str -> Try(Digest, DigestHexErr)
Crypto.BLAKE3.Digest.is_eq : Digest, Digest -> Bool
Crypto.BLAKE3.Digest.to_hash : Digest, Hasher -> Hasher
Crypto.BLAKE3.Digest.to_inspect : Digest -> Str
Crypto.BLAKE3.Hasher
Crypto.BLAKE3.Hasher.empty : -> Hasher
Crypto.BLAKE3.Hasher.write : Hasher, List(U8) -> Hasher
Crypto.BLAKE3.Hasher.finish : Hasher -> Digest
Dict.is_eq : Dict(k, v), Dict(k, v) -> Bool where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher, v.is_eq : v, v -> Bool]
Dict.to_hash : Dict(k, v), Hasher -> Hasher where [k.to_hash : k, Hasher -> Hasher, v.to_hash : v, Hasher -> Hasher]
Dict.empty : -> Dict(_k, _v)
Dict.with_capacity : U64 -> Dict(_k, _v)
Dict.capacity : Dict(_k, _v) -> U64
Dict.reserve : Dict(k, v), U64 -> Dict(k, v) where [k.to_hash : k, Hasher -> Hasher]
Dict.release_excess_capacity : Dict(k, v) -> Dict(k, v) where [k.to_hash : k, Hasher -> Hasher]
Dict.clear : Dict(k, v) -> Dict(k, v)
Dict.single : k, v -> Dict(k, v) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.len : Dict(_k, _v) -> U64
Dict.is_empty : Dict(_k, _v) -> Bool
Dict.get : Dict(k, v), k -> Try(v, [KeyNotFound, ..]) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.contains : Dict(k, _v), k -> Bool where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.insert : Dict(k, v), k, v -> Dict(k, v) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.remove : Dict(k, v), k -> Dict(k, v) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.to_list : Dict(k, v) -> List((k, v))
Dict.from_list : List((k, v)) -> Dict(k, v) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.keys : Dict(k, _v) -> List(k)
Dict.values : Dict(_k, v) -> List(v)
Dict.fold : Dict(k, v), state, (state, k, v -> state) -> state
Dict.keep_if : Dict(k, v), ((k, v) -> Bool) -> Dict(k, v) where [k.to_hash : k, Hasher -> Hasher]
Dict.drop_if : Dict(k, v), ((k, v) -> Bool) -> Dict(k, v) where [k.to_hash : k, Hasher -> Hasher]
Dict.map : Dict(k, a), (k, a -> b) -> Dict(k, b)
Dict.join_map : Dict(a, b), (a, b -> Dict(x, y)) -> Dict(x, y) where [x.is_eq : x, x -> Bool, x.to_hash : x, Hasher -> Hasher]
Dict.insert_all : Dict(k, v), Dict(k, v) -> Dict(k, v) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.keep_shared : Dict(k, v), Dict(k, v) -> Dict(k, v) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher, v.is_eq : v, v -> Bool]
Dict.remove_all : Dict(k, v), Dict(k, _w) -> Dict(k, v) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.update : Dict(k, v), k, (Try(v, [Missing]) -> Try(v, [Missing])) -> Dict(k, v) where [k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher]
Dict.DictBucket : { dist_and_fingerprint : U32, entry_index : U32 }
Dict.DictData : { entries : List((k, v)), buckets : List(DictBucket), max_entries_before_grow : U64, shifts : U8 }
Dict.DictMetadata : { buckets : List(DictBucket), max_entries_before_grow : U64, shifts : U8 }
Encoding.FieldName
Encoding.FieldName.name : FieldName(_shape) -> Str
Encoding.FieldName.FieldNames
Encoding.FieldName.FieldNames.rename_fields : FieldNames(_shape), (Str -> Str) -> FieldNames(_shape)
Encoding.FieldName.FieldNames.shortest_name : FieldNames(_shape) -> U64
Encoding.FieldName.FieldNames.longest_name : FieldNames(_shape) -> U64
Encoding.FieldName.FieldNames.iter : FieldNames(_shape) -> Iter(FieldName(_shape))
Encoding.FieldName.FieldNames.for_size : FieldNames(_shape), U64 -> Iter(FieldName(_shape))
Encoding.ParseTagUnionSpec
Encoding.ParseTagUnionSpec.parse : ParseTagUnionSpec(_shape), { tag : Str, encoding : _encoding, state : _state, missing : _err } -> Try({ value : _shape, rest : _state }, _err)
Encoding.JsonState
Encoding.JsonEncodeState
Encoding.Json
Encoding.Json.parse_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, ParseErr)
Encoding.Json.parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, ParseErr)
Encoding.Json.parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, ParseErr)
Encoding.Json.parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, ParseErr)
Encoding.Json.parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, ParseErr)
Encoding.Json.parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, ParseErr)
Encoding.Json.parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, ParseErr)
Encoding.Json.parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, ParseErr)
Encoding.Json.parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, ParseErr)
Encoding.Json.parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, ParseErr)
Encoding.Json.parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, ParseErr)
Encoding.Json.parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, ParseErr)
Encoding.Json.parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, ParseErr)
Encoding.Json.parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, ParseErr)
Encoding.Json.parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, ParseErr)
Encoding.Json.parse_null : JsonEncoding, JsonState -> Try(JsonState, ParseErr)
Encoding.Json.parse_array_start : JsonEncoding, JsonState -> Try(JsonState, ParseErr)
Encoding.Json.parse_array_next : JsonEncoding, JsonState -> Try([Element(JsonState), Done(JsonState)], ParseErr)
Encoding.Json.parse_array_after_element : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], ParseErr)
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_record : JsonEncoding, JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)
Encoding.Json.encode_tuple : JsonEncoding, JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)
Encoding.Json.encode_list : JsonEncoding, JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)
Encoding.Json.to_str : a -> Str where [a.encoder_for : JsonEncoding -> a, JsonEncodeState -> Try(JsonEncodeState, [])]
Encoding.Json.to_str_try : a -> Try(Str, err) where [a.encoder_for : JsonEncoding -> a, JsonEncodeState -> Try(JsonEncodeState, err)]
Encoding.Json.parse : Str -> Try(a, ParseErr) where [a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, ParseErr)]
Encoding.Json.parse_trailing_commas : Str -> Try(a, ParseErr) where [a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, ParseErr)]
Encoding.Json.parser_camel : -> Str -> Try(a, ParseErr) where [a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, ParseErr)]
Encoding.Json.invalid_json : ParseErr
Encoding.Json.parse_json_bool : Str -> Try({ value : Bool, rest : JsonState }, ParseErr)
Encoding.Json.parse_json_null : Str -> Try(JsonState, ParseErr)
Encoding.Json.parse_array_start_from_json : Str -> Try(JsonState, ParseErr)
Encoding.Json.parse_array_next_from_json : Str -> Try([Element(JsonState), Done(JsonState)], ParseErr)
Encoding.Json.parse_array_after_element_from_json : JsonEncoding, Str -> Try([Continue(JsonState), Done(JsonState)], ParseErr)
Encoding.Json.parse_json_unsigned_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, ParseErr)
Encoding.Json.parse_json_signed_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, ParseErr)
Encoding.Json.parse_json_number : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, ParseErr)
Encoding.Json.dec_from_json_number : Str -> Try(Dec, [BadNumStr])
Encoding.Json.split_json_number_exponent : Str -> Try({ mantissa : Str, exponent : Str }, [NotFound])
Encoding.Json.dec_from_json_exponent_parts : Str, Str -> Try(Dec, [BadNumStr])
Encoding.Json.json_dec_digits_are_zero : Str -> Bool
Encoding.Json.trim_json_dec_leading_zeros : Str, I64 -> { digits : Str, digits_len : U64, point : I64 }
Encoding.Json.normalize_json_dec_digits : Bool, Str, U64, I64 -> Try(Str, [BadNumStr])
Encoding.Json.parse_json_key_unsigned_int : Str, (Str -> Try(a, [BadNumStr])) -> Try(a, ParseErr)
Encoding.Json.parse_json_key_signed_int : Str, (Str -> Try(a, [BadNumStr])) -> Try(a, ParseErr)
Encoding.Json.parse_json_key_number : Str, (Str -> Try(a, [BadNumStr])) -> Try(a, ParseErr)
Encoding.Json.encode_json_number : Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.Json.container_needs_comma : JsonEncodeState -> Bool
Encoding.Json.mark_container_has_item : List(Bool) -> List(Bool)
Encoding.Json.write_record_start : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.Json.write_record_field : JsonEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)
Encoding.Json.write_record_end : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.Json.write_sequence_start : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.Json.write_sequence_element : JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)
Encoding.Json.write_sequence_end : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.Json.append_json_string_bytes : List(U8), Str -> List(U8)
Encoding.Json.append_json_quoted_string : List(U8), Str -> List(U8)
Encoding.Json.append_json_string_byte : List(U8), U8 -> List(U8)
Encoding.Json.append_json_unicode_escape : List(U8), U8 -> List(U8)
Encoding.Json.hex_digit_byte : U8 -> U8
Encoding.Json.parse_record_field_from_object : JsonEncoding, Str -> Try([Field({ field : FieldName(_shape), rest : JsonState }), TryField({ name : Str, rest : JsonState }), TryFieldCaseless({ name : Str, rest : JsonState }), Continue({ rest : JsonState }), Done({ rest : JsonState })], ParseErr)
Encoding.Json.parse_record_field_after_object_start : a, Str -> Try([Done({ rest : JsonState }), TryField({ name : Str, rest : JsonState })], ParseErr)
Encoding.Json.parse_record_field_after_value : JsonEncoding, Str -> Try([Done({ rest : JsonState }), ..[TryField({ name : Str, rest : JsonState })]], ParseErr)
Encoding.Json.parse_record_field_start : a, Str -> Try([TryField({ name : Str, rest : JsonState })], ParseErr)
Encoding.Json.snake_to_camel : Str -> Str
Encoding.Json.upper_first_ascii : Str -> Str
Encoding.Json.skip_json_value : JsonEncoding, JsonState -> Try(JsonState, ParseErr)
Encoding.Json.skip_json_object : JsonEncoding, Str -> Try(JsonState, ParseErr)
Encoding.Json.skip_json_array : JsonEncoding, Str -> Try(JsonState, ParseErr)
Encoding.Json.parse_tag_union_from_json : Str, JsonEncoding, ParseTagUnionSpec(a) -> Try({ value : a, rest : JsonState }, ParseErr)
Encoding.Json.finish_tag_payload : JsonEncoding, a, Str -> Try({ value : a, rest : JsonState }, ParseErr)
Encoding.Json.consume_empty_json_object : Str -> Try({ after : Str }, ParseErr)
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 }, ParseErr)
Encoding.Json.split_json_scalar_tail : Str -> Try({ value : Str, after : Str }, ParseErr)
Encoding.Json.ParseErr : [MissingRequiredField(Str), InvalidJson(Str)]
Encoding.JsonEncoding
Encoding.JsonEncoding.rename_field : JsonEncoding, Str -> Str
Encoding.JsonEncoding.allows_trailing_commas : JsonEncoding -> Bool
Encoding.JsonEncoding.parse_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.parse_null : JsonEncoding, JsonState -> Try(JsonState, ParseErr)
Encoding.JsonEncoding.parse_array_start : JsonEncoding, JsonState -> Try(JsonState, ParseErr)
Encoding.JsonEncoding.parse_array_next : JsonEncoding, JsonState -> Try([Element(JsonState), Done(JsonState)], ParseErr)
Encoding.JsonEncoding.parse_array_after_element : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], ParseErr)
Encoding.JsonEncoding.parse_record_field : JsonEncoding, FieldNames(_shape), JsonState -> Try([Field({ field : FieldName(_shape), rest : JsonState }), TryField({ name : Str, rest : JsonState }), TryFieldCaseless({ name : Str, rest : JsonState }), Continue({ rest : JsonState }), Done({ rest : JsonState })], ParseErr)
Encoding.JsonEncoding.parse_object_next : JsonEncoding, JsonState -> Try([Entry({ key : Str, rest : JsonState }), Done({ rest : JsonState })], ParseErr)
Encoding.JsonEncoding.skip_record_field : JsonEncoding, JsonState -> Try(JsonState, ParseErr)
Encoding.JsonEncoding.missing_record_field : JsonEncoding, Str, JsonState -> ParseErr
Encoding.JsonEncoding.missing_optional_field : JsonEncoding, Str, JsonState -> [Missing, ..]
Encoding.JsonEncoding.invalid_value : JsonEncoding, JsonState -> ParseErr
Encoding.JsonEncoding.parse_tag_union : JsonEncoding, ParseTagUnionSpec(a), JsonState -> Try({ value : a, rest : JsonState }, ParseErr)
Encoding.JsonEncoding.encode_record : JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)
Encoding.JsonEncoding.encode_tuple : JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)
Encoding.JsonEncoding.encode_list : JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)
Encoding.JsonEncoding.encode_str : Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_bool : Bool, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_u8 : U8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_i8 : I8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_u16 : U16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_i16 : I16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_u32 : U32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_i32 : I32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_u64 : U64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_i64 : I64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_u128 : U128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_i128 : I128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_dec : Dec, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.encode_f32 : F32, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])
Encoding.JsonEncoding.encode_f64 : F64, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])
Encoding.JsonEncoding.encode_null : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
Encoding.JsonEncoding.parse_key_str : JsonEncoding, Str -> Try(Str, ParseErr)
Encoding.JsonEncoding.parse_key_bool : JsonEncoding, Str -> Try(Bool, ParseErr)
Encoding.JsonEncoding.parse_key_u8 : JsonEncoding, Str -> Try(U8, ParseErr)
Encoding.JsonEncoding.parse_key_i8 : JsonEncoding, Str -> Try(I8, ParseErr)
Encoding.JsonEncoding.parse_key_u16 : JsonEncoding, Str -> Try(U16, ParseErr)
Encoding.JsonEncoding.parse_key_i16 : JsonEncoding, Str -> Try(I16, ParseErr)
Encoding.JsonEncoding.parse_key_u32 : JsonEncoding, Str -> Try(U32, ParseErr)
Encoding.JsonEncoding.parse_key_i32 : JsonEncoding, Str -> Try(I32, ParseErr)
Encoding.JsonEncoding.parse_key_u64 : JsonEncoding, Str -> Try(U64, ParseErr)
Encoding.JsonEncoding.parse_key_i64 : JsonEncoding, Str -> Try(I64, ParseErr)
Encoding.JsonEncoding.parse_key_u128 : JsonEncoding, Str -> Try(U128, ParseErr)
Encoding.JsonEncoding.parse_key_i128 : JsonEncoding, Str -> Try(I128, ParseErr)
Encoding.JsonEncoding.parse_key_dec : JsonEncoding, Str -> Try(Dec, ParseErr)
Encoding.JsonEncoding.parse_key_f32 : JsonEncoding, Str -> Try(F32, ParseErr)
Encoding.JsonEncoding.parse_key_f64 : JsonEncoding, Str -> Try(F64, ParseErr)
Encoding.JsonEncoding.encode_key_str : JsonEncoding, Str -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_bool : JsonEncoding, Bool -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_u8 : JsonEncoding, U8 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_i8 : JsonEncoding, I8 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_u16 : JsonEncoding, U16 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_i16 : JsonEncoding, I16 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_u32 : JsonEncoding, U32 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_i32 : JsonEncoding, I32 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_u64 : JsonEncoding, U64 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_i64 : JsonEncoding, I64 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_u128 : JsonEncoding, U128 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_i128 : JsonEncoding, I128 -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_dec : JsonEncoding, Dec -> Try(Str, _never_fails)
Encoding.JsonEncoding.encode_key_f32 : JsonEncoding, F32 -> Try(Str, [Infinity, NaN, NegativeInfinity])
Encoding.JsonEncoding.encode_key_f64 : JsonEncoding, F64 -> Try(Str, [Infinity, NaN, NegativeInfinity])
Encoding.HttpHeaderState
Encoding.HttpHeaderEncoding
Encoding.HttpHeaderEncoding.rename_field : HttpHeaderEncoding, Str -> Str
Encoding.HttpHeaderEncoding.parse_str : HttpHeaderEncoding, HttpHeaderState -> Try({ value : Str, rest : HttpHeaderState }, HttpHeader)
Encoding.HttpHeaderEncoding.parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, HttpHeader)
Encoding.HttpHeaderEncoding.parse_record_field : HttpHeaderEncoding, FieldNames(_shape), HttpHeaderState -> Try([Field({ field : FieldName(_shape), rest : HttpHeaderState }), TryField({ name : Str, rest : HttpHeaderState }), TryFieldCaseless({ name : Str, rest : HttpHeaderState }), Continue({ rest : HttpHeaderState }), Done({ rest : HttpHeaderState })], HttpHeader)
Encoding.HttpHeaderEncoding.skip_record_field : HttpHeaderEncoding, HttpHeaderState -> Try(HttpHeaderState, HttpHeader)
Encoding.HttpHeaderEncoding.missing_record_field : HttpHeaderEncoding, Str, HttpHeaderState -> HttpHeader
Encoding.HttpHeaderEncoding.missing_optional_field : HttpHeaderEncoding, Str, HttpHeaderState -> [Missing]
Encoding.HttpHeader := [MissingRequired, BadHeader]
Encoding.HttpHeader.parser_for : -> Str -> Try(output, HttpHeader) where [output.parser_for : HttpHeaderEncoding -> HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, HttpHeader)]
Encoding.HttpHeader.parse : Str -> Try(output, HttpHeader) where [output.parser_for : HttpHeaderEncoding -> HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, HttpHeader)]
Encoding.HttpHeader.parse_str : HttpHeaderEncoding, HttpHeaderState -> Try({ value : Str, rest : HttpHeaderState }, HttpHeader)
Encoding.HttpHeader.parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, HttpHeader)
Encoding.HttpHeader.parse_record_field_from_headers : FieldNames(_shape), Str -> Try([Field({ field : FieldName(_shape), rest : HttpHeaderState }), TryField({ name : Str, rest : HttpHeaderState }), TryFieldCaseless({ name : Str, rest : HttpHeaderState }), Continue({ rest : HttpHeaderState }), Done({ rest : HttpHeaderState })], HttpHeader)
Encoding.HttpHeader.take_header_value : Str -> Try({ value : Str, after : Str }, HttpHeader)
Encoding.HttpHeader.underscores_to_dashes : Str -> Str
Hasher.write_bool : Hasher, Bool -> Hasher
Hasher.write_u8 : Hasher, U8 -> Hasher
Hasher.write_u16 : Hasher, U16 -> Hasher
Hasher.write_u32 : Hasher, U32 -> Hasher
Hasher.write_u64 : Hasher, U64 -> Hasher
Hasher.write_u128 : Hasher, U128 -> Hasher
Hasher.write_i8 : Hasher, I8 -> Hasher
Hasher.write_i16 : Hasher, I16 -> Hasher
Hasher.write_i32 : Hasher, I32 -> Hasher
Hasher.write_i64 : Hasher, I64 -> Hasher
Hasher.write_i128 : Hasher, I128 -> Hasher
Hasher.write_f32 : Hasher, F32 -> Hasher
Hasher.write_f64 : Hasher, F64 -> Hasher
Hasher.write_dec : Hasher, Dec -> Hasher
Hasher.write_bytes : Hasher, List(U8) -> Hasher
Hasher.write_str : Hasher, Str -> Hasher
Iter.custom : state, [Known(U64), Unknown], (state -> Try((item, state), [NoMore])) -> Iter(item)
Iter.range_exclusive : num, num -> Iter(num) where [num.range_exclusive : num, num -> Iter(num)]
Iter.range_inclusive : num, num -> Iter(num) where [num.range_inclusive : num, num -> Iter(num)]
Iter.exclusive_range : num, num, [Known(U64), Unknown] -> Iter(num) where [num.is_lt : num, num -> Bool, num.add_try : num, num -> Try(num, [Overflow]), num.from_numeral : Numeral -> Try(num, [InvalidNumeral(Str)])]
Iter.inclusive_range : num, num, [Known(U64), Unknown] -> Iter(num) where [num.is_lte : num, num -> Bool, num.add_try : num, num -> Try(num, [Overflow]), num.from_numeral : Numeral -> Try(num, [InvalidNumeral(Str)])]
Iter.iter : Iter(item) -> Iter(item)
Iter.single : item -> Iter(item)
Iter.prepended : Iter(item), item -> Iter(item)
Iter.concat : Iter(item), Iter(item) -> Iter(item)
Iter.append : Iter(item), item -> Iter(item)
Iter.next : Iter(item) -> [One({ item : item, rest : Iter(item) }), Skip({ rest : Iter(item) }), Done]
Iter.map : Iter(a), (a -> b) -> Iter(b)
Iter.keep_if : Iter(a), (a -> Bool) -> Iter(a)
Iter.drop_if : Iter(a), (a -> Bool) -> Iter(a)
Iter.fold : Iter(a), acc, (acc, a -> acc) -> acc
Iter.size_hint : Iter(item) -> [Known(U64), Unknown]
Iter.collect : Iter(item) -> output where [output.from_iter : Iter(item) -> output]
Iter.stream : Iter(item) -> Stream(item)
Iter.take_first : Iter(item), U64 -> Iter(item)
Iter.drop_first : Iter(item), U64 -> Iter(item)
Iter.take_last : Iter(item), U64 -> Iter(item)
Iter.drop_last : Iter(item), U64 -> Iter(item)
Iter.step_by : Iter(item), U64 -> Iter(item)
Iter.rev : Iter(item) -> Iter(item)
List.len : List(_item) -> U64
List.is_empty : List(_item) -> Bool
List.iter : List(item) -> Iter(item)
List.from_iter : Iter(item) -> List(item)
List.concat : List(item), List(item) -> List(item)
List.with_capacity : U64 -> List(item)
List.reserve : List(item), U64 -> List(item)
List.release_excess_capacity : List(item) -> List(item)
List.sort_with : List(item), (item, item -> [LT, EQ, GT]) -> List(item)
List.is_eq : List(item), List(item) -> Bool where [item.is_eq : item, item -> Bool]
List.to_hash : List(item), Hasher -> Hasher where [item.to_hash : item, Hasher -> Hasher]
List.append : List(a), a -> List(a)
List.append_if_ok : List(a), Try(a, err) -> List(a)
List.prepend : List(a), a -> List(a)
List.first : List(item) -> Try(item, [ListWasEmpty, ..])
List.get : List(item), U64 -> Try(item, [OutOfBounds, ..])
List.subscript : List(item), U64 -> Try(item, [OutOfBounds, ..])
List.set : List(a), U64, a -> Try(List(a), [OutOfBounds, ..])
List.replace : List(a), U64, a -> Try({ list : List(a), prev : a }, [OutOfBounds, ..])
List.update : List(a), U64, (a -> a) -> Try(List(a), [OutOfBounds, ..])
List.swap : List(a), U64, U64 -> Try(List(a), [OutOfBounds, ..])
List.rev : List(item) -> List(item)
List.for_each! : List(item), (item => { }) => { }
List.map : List(a), (a -> b) -> List(b)
List.map_with_index : List(a), (a, U64 -> b) -> List(b)
List.map2 : List(a), List(b), (a, b -> c) -> List(c)
List.keep_if : List(a), (a -> Bool) -> List(a)
List.drop_if : List(a), (a -> Bool) -> List(a)
List.count_if : List(a), (a -> Bool) -> U64
List.fold : List(item), state, (state, item -> state) -> state
List.fold_with_index : List(item), state, (state, item, U64 -> state) -> state
List.fold_until : List(item), state, (state, item -> [Continue(state), Break(state)]) -> state
List.fold_with_index_until : List(item), state, (state, item, U64 -> [Continue(state), Break(state)]) -> state
List.fold_rev : List(item), state, (item, state -> state) -> state
List.starts_with : List(a), List(a) -> Bool where [a.is_eq : a, a -> Bool]
List.ends_with : List(a), List(a) -> Bool where [a.is_eq : a, a -> Bool]
List.any : List(a), (a -> Bool) -> Bool
List.contains : List(a), a -> Bool where [a.is_eq : a, a -> Bool]
List.all : List(a), (a -> Bool) -> Bool
List.last : List(item) -> Try(item, [ListWasEmpty, ..])
List.single : item -> List(item)
List.drop_at : List(a), U64 -> List(a)
List.sublist : List(a), { start : U64, len : U64 } -> List(a)
List.take_first : List(a), U64 -> List(a)
List.take_last : List(a), U64 -> List(a)
List.drop_first : List(a), U64 -> List(a)
List.drop_last : List(a), U64 -> List(a)
List.find_first : List(a), (a -> Bool) -> Try(a, [NotFound])
List.find_last : List(a), (a -> Bool) -> Try(a, [NotFound])
List.find_first_index : List(a), (a -> Bool) -> Try(U64, [NotFound])
List.find_last_index : List(a), (a -> Bool) -> Try(U64, [NotFound])
List.split_at : List(a), U64 -> { before : List(a), others : List(a) }
List.split_on : List(a), a -> List(List(a)) where [a.is_eq : a, a -> Bool]
List.split_if : List(a), (a -> Bool) -> List(List(a))
List.split_on_list : List(a), List(a) -> List(List(a)) where [a.is_eq : a, a -> Bool]
List.split_first : List(a), a -> Try({ before : List(a), after : List(a) }, [NotFound]) where [a.is_eq : a, a -> Bool]
List.split_last : List(a), a -> Try({ before : List(a), after : List(a) }, [NotFound]) where [a.is_eq : a, a -> Bool]
List.repeat : a, U64 -> List(a)
List.sum : List(item) -> item where [item.plus : item, item -> item, item.default : -> item]
List.min : List(a) -> Try(a, [ListWasEmpty]) where [a.min : a, a -> a]
List.max : List(a) -> Try(a, [ListWasEmpty]) where [a.max : a, a -> a]
List.encoder_for : encoding -> List(item), state -> Try(state, err) where [item.encoder_for : encoding -> item, state -> Try(state, err), encoding.encode_list : state, U64, (state, (state, (state -> Try(state, err)) -> Try(state, err)) -> Try(state, err)) -> Try(state, err)]
List.decode : src, fmt -> (Try(List(item), err), src) where [fmt.decode_list : fmt, src, (src, fmt -> (Try(item, err), src)) -> (Try(List(item), err), src), item.decode : src, fmt -> (Try(item, err), src)]
Num.Numeral
Num.Numeral.is_negative : Numeral -> Bool
Num.Numeral.digits_before_pt : Numeral -> List(U8)
Num.Numeral.digits_after_pt : Numeral -> List(U8)
Num.Numeral.digits_after_pt_count : Numeral -> U64
Num.U8
Num.U8.default : -> U8
Num.U8.highest : U8
Num.U8.lowest : U8
Num.U8.to_str : U8 -> Str
Num.U8.is_zero : U8 -> Bool
Num.U8.is_eq : U8, U8 -> Bool
Num.U8.to_hash : U8, Hasher -> Hasher
Num.U8.is_gt : U8, U8 -> Bool
Num.U8.is_gte : U8, U8 -> Bool
Num.U8.is_lt : U8, U8 -> Bool
Num.U8.is_lte : U8, U8 -> Bool
Num.U8.compare : U8, U8 -> [LT, EQ, GT]
Num.U8.is_even : U8 -> Bool
Num.U8.is_odd : U8 -> Bool
Num.U8.is_multiple_of : U8, U8 -> Bool
Num.U8.max : U8, U8 -> U8
Num.U8.min : U8, U8 -> U8
Num.U8.plus : U8, U8 -> U8
Num.U8.add_try : U8, U8 -> Try(U8, [Overflow, ..])
Num.U8.range_exclusive : U8, U8 -> Iter(U8)
Num.U8.range_inclusive : U8, U8 -> Iter(U8)
Num.U8.plus_saturated : U8, U8 -> U8
Num.U8.minus : U8, U8 -> U8
Num.U8.sub_try : U8, U8 -> Try(U8, [Overflow, ..])
Num.U8.minus_saturated : U8, U8 -> U8
Num.U8.times : U8, U8 -> U8
Num.U8.mul_try : U8, U8 -> Try(U8, [Overflow, ..])
Num.U8.times_saturated : U8, U8 -> U8
Num.U8.pow : U8, U8 -> U8
Num.U8.pow_try : U8, U8 -> Try(U8, [Overflow, ..])
Num.U8.div_by : U8, U8 -> U8
Num.U8.div_try : U8, U8 -> Try(U8, [DivByZero, ..])
Num.U8.div_ceil_by : U8, U8 -> U8
Num.U8.div_ceil_try : U8, U8 -> Try(U8, [DivByZero, ..])
Num.U8.div_floor_by : U8, U8 -> U8
Num.U8.div_trunc_by : U8, U8 -> U8
Num.U8.rem_by : U8, U8 -> U8
Num.U8.mod_by : U8, U8 -> U8
Num.U8.abs_diff : U8, U8 -> U8
Num.U8.shift_left_by : U8, U8 -> U8
Num.U8.shift_right_by : U8, U8 -> U8
Num.U8.shift_right_zf_by : U8, U8 -> U8
Num.U8.bitwise_and : U8, U8 -> U8
Num.U8.bitwise_or : U8, U8 -> U8
Num.U8.bitwise_xor : U8, U8 -> U8
Num.U8.bitwise_not : U8 -> U8
Num.U8.count_leading_zero_bits : U8 -> U8
Num.U8.count_trailing_zero_bits : U8 -> U8
Num.U8.count_one_bits : U8 -> U8
Num.U8.from_int_digits : List(U8) -> Try(U8, [OutOfRange])
Num.U8.from_numeral : Numeral -> Try(U8, [InvalidNumeral(Str)])
Num.U8.from_str : Str -> Try(U8, [BadNumStr, ..])
Num.U8.to : U8, U8 -> Iter(U8)
Num.U8.until : U8, U8 -> Iter(U8)
Num.U8.to_i8_wrap : U8 -> I8
Num.U8.to_i8_try : U8 -> Try(I8, [OutOfRange, ..])
Num.U8.to_i16 : U8 -> I16
Num.U8.to_i32 : U8 -> I32
Num.U8.to_i64 : U8 -> I64
Num.U8.to_i128 : U8 -> I128
Num.U8.to_u8 : U8 -> U8
Num.U8.to_u8_try : U8 -> Try(U8, _never_fails)
Num.U8.to_u8_wrap : U8 -> U8
Num.U8.to_u16 : U8 -> U16
Num.U8.to_u32 : U8 -> U32
Num.U8.to_u64 : U8 -> U64
Num.U8.to_u128 : U8 -> U128
Num.U8.to_f32 : U8 -> F32
Num.U8.to_f64 : U8 -> F64
Num.U8.to_dec : U8 -> Dec
Num.U8.encode : U8, fmt -> Try(encoded, err) where [fmt.encode_u8 : fmt, U8 -> Try(encoded, err)]
Num.U8.decode : src, fmt -> (Try(U8, err), src) where [fmt.decode_u8 : fmt, src -> (Try(U8, err), src)]
Num.I8
Num.I8.default : -> I8
Num.I8.highest : I8
Num.I8.lowest : I8
Num.I8.to_str : I8 -> Str
Num.I8.is_zero : I8 -> Bool
Num.I8.is_negative : I8 -> Bool
Num.I8.is_positive : I8 -> Bool
Num.I8.is_eq : I8, I8 -> Bool
Num.I8.to_hash : I8, Hasher -> Hasher
Num.I8.is_gt : I8, I8 -> Bool
Num.I8.is_gte : I8, I8 -> Bool
Num.I8.is_lt : I8, I8 -> Bool
Num.I8.is_lte : I8, I8 -> Bool
Num.I8.compare : I8, I8 -> [LT, EQ, GT]
Num.I8.is_even : I8 -> Bool
Num.I8.is_odd : I8 -> Bool
Num.I8.is_multiple_of : I8, I8 -> Bool
Num.I8.max : I8, I8 -> I8
Num.I8.min : I8, I8 -> I8
Num.I8.negate : I8 -> I8
Num.I8.abs : I8 -> I8
Num.I8.plus : I8, I8 -> I8
Num.I8.add_try : I8, I8 -> Try(I8, [Overflow, ..])
Num.I8.range_exclusive : I8, I8 -> Iter(I8)
Num.I8.range_inclusive : I8, I8 -> Iter(I8)
Num.I8.plus_saturated : I8, I8 -> I8
Num.I8.minus : I8, I8 -> I8
Num.I8.sub_try : I8, I8 -> Try(I8, [Overflow, ..])
Num.I8.minus_saturated : I8, I8 -> I8
Num.I8.times : I8, I8 -> I8
Num.I8.mul_try : I8, I8 -> Try(I8, [Overflow, ..])
Num.I8.times_saturated : I8, I8 -> I8
Num.I8.pow : I8, I8 -> I8
Num.I8.pow_try : I8, I8 -> Try(I8, [Overflow, Underflow, ..])
Num.I8.div_by : I8, I8 -> I8
Num.I8.div_try : I8, I8 -> Try(I8, [DivByZero, Overflow, ..])
Num.I8.div_ceil_by : I8, I8 -> I8
Num.I8.div_ceil_try : I8, I8 -> Try(I8, [DivByZero, Overflow, ..])
Num.I8.div_floor_by : I8, I8 -> I8
Num.I8.div_trunc_by : I8, I8 -> I8
Num.I8.rem_by : I8, I8 -> I8
Num.I8.mod_by : I8, I8 -> I8
Num.I8.abs_diff : I8, I8 -> U8
Num.I8.shift_left_by : I8, U8 -> I8
Num.I8.shift_right_by : I8, U8 -> I8
Num.I8.shift_right_zf_by : I8, U8 -> I8
Num.I8.bitwise_and : I8, I8 -> I8
Num.I8.bitwise_or : I8, I8 -> I8
Num.I8.bitwise_xor : I8, I8 -> I8
Num.I8.bitwise_not : I8 -> I8
Num.I8.count_leading_zero_bits : I8 -> U8
Num.I8.count_trailing_zero_bits : I8 -> U8
Num.I8.count_one_bits : I8 -> U8
Num.I8.to : I8, I8 -> Iter(I8)
Num.I8.until : I8, I8 -> Iter(I8)
Num.I8.from_int_digits : List(U8) -> Try(I8, [OutOfRange])
Num.I8.from_numeral : Numeral -> Try(I8, [InvalidNumeral(Str)])
Num.I8.from_str : Str -> Try(I8, [BadNumStr, ..])
Num.I8.to_i8 : I8 -> I8
Num.I8.to_i8_try : I8 -> Try(I8, _never_fails)
Num.I8.to_i8_wrap : I8 -> I8
Num.I8.to_i16 : I8 -> I16
Num.I8.to_i32 : I8 -> I32
Num.I8.to_i64 : I8 -> I64
Num.I8.to_i128 : I8 -> I128
Num.I8.to_u8_wrap : I8 -> U8
Num.I8.to_u8_try : I8 -> Try(U8, [OutOfRange, ..])
Num.I8.to_u16_wrap : I8 -> U16
Num.I8.to_u16_try : I8 -> Try(U16, [OutOfRange, ..])
Num.I8.to_u32_wrap : I8 -> U32
Num.I8.to_u32_try : I8 -> Try(U32, [OutOfRange, ..])
Num.I8.to_u64_wrap : I8 -> U64
Num.I8.to_u64_try : I8 -> Try(U64, [OutOfRange, ..])
Num.I8.to_u128_wrap : I8 -> U128
Num.I8.to_u128_try : I8 -> Try(U128, [OutOfRange, ..])
Num.I8.to_f32 : I8 -> F32
Num.I8.to_f64 : I8 -> F64
Num.I8.to_dec : I8 -> Dec
Num.I8.encode : I8, fmt -> Try(encoded, err) where [fmt.encode_i8 : fmt, I8 -> Try(encoded, err)]
Num.I8.decode : src, fmt -> (Try(I8, err), src) where [fmt.decode_i8 : fmt, src -> (Try(I8, err), src)]
Num.U16
Num.U16.default : -> U16
Num.U16.highest : U16
Num.U16.lowest : U16
Num.U16.to_str : U16 -> Str
Num.U16.is_zero : U16 -> Bool
Num.U16.is_eq : U16, U16 -> Bool
Num.U16.to_hash : U16, Hasher -> Hasher
Num.U16.is_gt : U16, U16 -> Bool
Num.U16.is_gte : U16, U16 -> Bool
Num.U16.is_lt : U16, U16 -> Bool
Num.U16.is_lte : U16, U16 -> Bool
Num.U16.compare : U16, U16 -> [LT, EQ, GT]
Num.U16.is_even : U16 -> Bool
Num.U16.is_odd : U16 -> Bool
Num.U16.is_multiple_of : U16, U16 -> Bool
Num.U16.max : U16, U16 -> U16
Num.U16.min : U16, U16 -> U16
Num.U16.plus : U16, U16 -> U16
Num.U16.add_try : U16, U16 -> Try(U16, [Overflow, ..])
Num.U16.range_exclusive : U16, U16 -> Iter(U16)
Num.U16.range_inclusive : U16, U16 -> Iter(U16)
Num.U16.plus_saturated : U16, U16 -> U16
Num.U16.minus : U16, U16 -> U16
Num.U16.sub_try : U16, U16 -> Try(U16, [Overflow, ..])
Num.U16.minus_saturated : U16, U16 -> U16
Num.U16.times : U16, U16 -> U16
Num.U16.mul_try : U16, U16 -> Try(U16, [Overflow, ..])
Num.U16.times_saturated : U16, U16 -> U16
Num.U16.pow : U16, U16 -> U16
Num.U16.pow_try : U16, U16 -> Try(U16, [Overflow, ..])
Num.U16.div_by : U16, U16 -> U16
Num.U16.div_try : U16, U16 -> Try(U16, [DivByZero, ..])
Num.U16.div_ceil_by : U16, U16 -> U16
Num.U16.div_ceil_try : U16, U16 -> Try(U16, [DivByZero, ..])
Num.U16.div_floor_by : U16, U16 -> U16
Num.U16.div_trunc_by : U16, U16 -> U16
Num.U16.rem_by : U16, U16 -> U16
Num.U16.mod_by : U16, U16 -> U16
Num.U16.abs_diff : U16, U16 -> U16
Num.U16.shift_left_by : U16, U8 -> U16
Num.U16.shift_right_by : U16, U8 -> U16
Num.U16.shift_right_zf_by : U16, U8 -> U16
Num.U16.bitwise_and : U16, U16 -> U16
Num.U16.bitwise_or : U16, U16 -> U16
Num.U16.bitwise_xor : U16, U16 -> U16
Num.U16.bitwise_not : U16 -> U16
Num.U16.count_leading_zero_bits : U16 -> U8
Num.U16.count_trailing_zero_bits : U16 -> U8
Num.U16.count_one_bits : U16 -> U8
Num.U16.to : U16, U16 -> Iter(U16)
Num.U16.until : U16, U16 -> Iter(U16)
Num.U16.from_int_digits : List(U8) -> Try(U16, [OutOfRange])
Num.U16.from_numeral : Numeral -> Try(U16, [InvalidNumeral(Str)])
Num.U16.from_str : Str -> Try(U16, [BadNumStr, ..])
Num.U16.to_i8_wrap : U16 -> I8
Num.U16.to_i8_try : U16 -> Try(I8, [OutOfRange, ..])
Num.U16.to_i16_wrap : U16 -> I16
Num.U16.to_i16_try : U16 -> Try(I16, [OutOfRange, ..])
Num.U16.to_i32 : U16 -> I32
Num.U16.to_i64 : U16 -> I64
Num.U16.to_i128 : U16 -> I128
Num.U16.to_u8_wrap : U16 -> U8
Num.U16.to_u8_try : U16 -> Try(U8, [OutOfRange, ..])
Num.U16.to_u16 : U16 -> U16
Num.U16.to_u16_try : U16 -> Try(U16, _never_fails)
Num.U16.to_u16_wrap : U16 -> U16
Num.U16.to_u32 : U16 -> U32
Num.U16.to_u64 : U16 -> U64
Num.U16.to_u128 : U16 -> U128
Num.U16.to_f32 : U16 -> F32
Num.U16.to_f64 : U16 -> F64
Num.U16.to_dec : U16 -> Dec
Num.U16.encode : U16, fmt -> Try(encoded, err) where [fmt.encode_u16 : fmt, U16 -> Try(encoded, err)]
Num.U16.decode : src, fmt -> (Try(U16, err), src) where [fmt.decode_u16 : fmt, src -> (Try(U16, err), src)]
Num.I16
Num.I16.default : -> I16
Num.I16.highest : I16
Num.I16.lowest : I16
Num.I16.to_str : I16 -> Str
Num.I16.is_zero : I16 -> Bool
Num.I16.is_negative : I16 -> Bool
Num.I16.is_positive : I16 -> Bool
Num.I16.is_eq : I16, I16 -> Bool
Num.I16.to_hash : I16, Hasher -> Hasher
Num.I16.is_gt : I16, I16 -> Bool
Num.I16.is_gte : I16, I16 -> Bool
Num.I16.is_lt : I16, I16 -> Bool
Num.I16.is_lte : I16, I16 -> Bool
Num.I16.compare : I16, I16 -> [LT, EQ, GT]
Num.I16.is_even : I16 -> Bool
Num.I16.is_odd : I16 -> Bool
Num.I16.is_multiple_of : I16, I16 -> Bool
Num.I16.max : I16, I16 -> I16
Num.I16.min : I16, I16 -> I16
Num.I16.negate : I16 -> I16
Num.I16.abs : I16 -> I16
Num.I16.plus : I16, I16 -> I16
Num.I16.add_try : I16, I16 -> Try(I16, [Overflow, ..])
Num.I16.range_exclusive : I16, I16 -> Iter(I16)
Num.I16.range_inclusive : I16, I16 -> Iter(I16)
Num.I16.plus_saturated : I16, I16 -> I16
Num.I16.minus : I16, I16 -> I16
Num.I16.sub_try : I16, I16 -> Try(I16, [Overflow, ..])
Num.I16.minus_saturated : I16, I16 -> I16
Num.I16.times : I16, I16 -> I16
Num.I16.mul_try : I16, I16 -> Try(I16, [Overflow, ..])
Num.I16.times_saturated : I16, I16 -> I16
Num.I16.pow : I16, I16 -> I16
Num.I16.pow_try : I16, I16 -> Try(I16, [Overflow, Underflow, ..])
Num.I16.div_by : I16, I16 -> I16
Num.I16.div_try : I16, I16 -> Try(I16, [DivByZero, Overflow, ..])
Num.I16.div_ceil_by : I16, I16 -> I16
Num.I16.div_ceil_try : I16, I16 -> Try(I16, [DivByZero, Overflow, ..])
Num.I16.div_floor_by : I16, I16 -> I16
Num.I16.div_trunc_by : I16, I16 -> I16
Num.I16.rem_by : I16, I16 -> I16
Num.I16.mod_by : I16, I16 -> I16
Num.I16.abs_diff : I16, I16 -> U16
Num.I16.shift_left_by : I16, U8 -> I16
Num.I16.shift_right_by : I16, U8 -> I16
Num.I16.shift_right_zf_by : I16, U8 -> I16
Num.I16.bitwise_and : I16, I16 -> I16
Num.I16.bitwise_or : I16, I16 -> I16
Num.I16.bitwise_xor : I16, I16 -> I16
Num.I16.bitwise_not : I16 -> I16
Num.I16.count_leading_zero_bits : I16 -> U8
Num.I16.count_trailing_zero_bits : I16 -> U8
Num.I16.count_one_bits : I16 -> U8
Num.I16.to : I16, I16 -> Iter(I16)
Num.I16.until : I16, I16 -> Iter(I16)
Num.I16.from_int_digits : List(U8) -> Try(I16, [OutOfRange])
Num.I16.from_numeral : Numeral -> Try(I16, [InvalidNumeral(Str)])
Num.I16.from_str : Str -> Try(I16, [BadNumStr, ..])
Num.I16.to_i8_wrap : I16 -> I8
Num.I16.to_i8_try : I16 -> Try(I8, [OutOfRange, ..])
Num.I16.to_i16 : I16 -> I16
Num.I16.to_i16_try : I16 -> Try(I16, _never_fails)
Num.I16.to_i16_wrap : I16 -> I16
Num.I16.to_i32 : I16 -> I32
Num.I16.to_i64 : I16 -> I64
Num.I16.to_i128 : I16 -> I128
Num.I16.to_u8_wrap : I16 -> U8
Num.I16.to_u8_try : I16 -> Try(U8, [OutOfRange, ..])
Num.I16.to_u16_wrap : I16 -> U16
Num.I16.to_u16_try : I16 -> Try(U16, [OutOfRange, ..])
Num.I16.to_u32_wrap : I16 -> U32
Num.I16.to_u32_try : I16 -> Try(U32, [OutOfRange, ..])
Num.I16.to_u64_wrap : I16 -> U64
Num.I16.to_u64_try : I16 -> Try(U64, [OutOfRange, ..])
Num.I16.to_u128_wrap : I16 -> U128
Num.I16.to_u128_try : I16 -> Try(U128, [OutOfRange, ..])
Num.I16.to_f32 : I16 -> F32
Num.I16.to_f64 : I16 -> F64
Num.I16.to_dec : I16 -> Dec
Num.I16.encode : I16, fmt -> Try(encoded, err) where [fmt.encode_i16 : fmt, I16 -> Try(encoded, err)]
Num.I16.decode : src, fmt -> (Try(I16, err), src) where [fmt.decode_i16 : fmt, src -> (Try(I16, err), src)]
Num.U32
Num.U32.default : -> U32
Num.U32.highest : U32
Num.U32.lowest : U32
Num.U32.to_str : U32 -> Str
Num.U32.is_zero : U32 -> Bool
Num.U32.is_eq : U32, U32 -> Bool
Num.U32.to_hash : U32, Hasher -> Hasher
Num.U32.is_gt : U32, U32 -> Bool
Num.U32.is_gte : U32, U32 -> Bool
Num.U32.is_lt : U32, U32 -> Bool
Num.U32.is_lte : U32, U32 -> Bool
Num.U32.compare : U32, U32 -> [LT, EQ, GT]
Num.U32.is_even : U32 -> Bool
Num.U32.is_odd : U32 -> Bool
Num.U32.is_multiple_of : U32, U32 -> Bool
Num.U32.max : U32, U32 -> U32
Num.U32.min : U32, U32 -> U32
Num.U32.plus : U32, U32 -> U32
Num.U32.add_try : U32, U32 -> Try(U32, [Overflow, ..])
Num.U32.range_exclusive : U32, U32 -> Iter(U32)
Num.U32.range_inclusive : U32, U32 -> Iter(U32)
Num.U32.plus_saturated : U32, U32 -> U32
Num.U32.minus : U32, U32 -> U32
Num.U32.sub_try : U32, U32 -> Try(U32, [Overflow, ..])
Num.U32.minus_saturated : U32, U32 -> U32
Num.U32.times : U32, U32 -> U32
Num.U32.mul_try : U32, U32 -> Try(U32, [Overflow, ..])
Num.U32.times_saturated : U32, U32 -> U32
Num.U32.pow : U32, U32 -> U32
Num.U32.pow_try : U32, U32 -> Try(U32, [Overflow, ..])
Num.U32.div_by : U32, U32 -> U32
Num.U32.div_try : U32, U32 -> Try(U32, [DivByZero, ..])
Num.U32.div_ceil_by : U32, U32 -> U32
Num.U32.div_ceil_try : U32, U32 -> Try(U32, [DivByZero, ..])
Num.U32.div_floor_by : U32, U32 -> U32
Num.U32.div_trunc_by : U32, U32 -> U32
Num.U32.rem_by : U32, U32 -> U32
Num.U32.mod_by : U32, U32 -> U32
Num.U32.abs_diff : U32, U32 -> U32
Num.U32.shift_left_by : U32, U8 -> U32
Num.U32.shift_right_by : U32, U8 -> U32
Num.U32.shift_right_zf_by : U32, U8 -> U32
Num.U32.bitwise_and : U32, U32 -> U32
Num.U32.bitwise_or : U32, U32 -> U32
Num.U32.bitwise_xor : U32, U32 -> U32
Num.U32.bitwise_not : U32 -> U32
Num.U32.count_leading_zero_bits : U32 -> U8
Num.U32.count_trailing_zero_bits : U32 -> U8
Num.U32.count_one_bits : U32 -> U8
Num.U32.to : U32, U32 -> Iter(U32)
Num.U32.until : U32, U32 -> Iter(U32)
Num.U32.from_int_digits : List(U8) -> Try(U32, [OutOfRange])
Num.U32.from_numeral : Numeral -> Try(U32, [InvalidNumeral(Str)])
Num.U32.from_str : Str -> Try(U32, [BadNumStr, ..])
Num.U32.to_i8_wrap : U32 -> I8
Num.U32.to_i8_try : U32 -> Try(I8, [OutOfRange, ..])
Num.U32.to_i16_wrap : U32 -> I16
Num.U32.to_i16_try : U32 -> Try(I16, [OutOfRange, ..])
Num.U32.to_i32_wrap : U32 -> I32
Num.U32.to_i32_try : U32 -> Try(I32, [OutOfRange, ..])
Num.U32.to_i64 : U32 -> I64
Num.U32.to_i128 : U32 -> I128
Num.U32.to_u8_wrap : U32 -> U8
Num.U32.to_u8_try : U32 -> Try(U8, [OutOfRange, ..])
Num.U32.to_u16_wrap : U32 -> U16
Num.U32.to_u16_try : U32 -> Try(U16, [OutOfRange, ..])
Num.U32.to_u32 : U32 -> U32
Num.U32.to_u32_try : U32 -> Try(U32, _never_fails)
Num.U32.to_u32_wrap : U32 -> U32
Num.U32.to_u64 : U32 -> U64
Num.U32.to_u128 : U32 -> U128
Num.U32.to_f32 : U32 -> F32
Num.U32.to_f64 : U32 -> F64
Num.U32.to_dec : U32 -> Dec
Num.U32.encode : U32, fmt -> Try(encoded, err) where [fmt.encode_u32 : fmt, U32 -> Try(encoded, err)]
Num.U32.decode : src, fmt -> (Try(U32, err), src) where [fmt.decode_u32 : fmt, src -> (Try(U32, err), src)]
Num.I32
Num.I32.default : -> I32
Num.I32.highest : I32
Num.I32.lowest : I32
Num.I32.to_str : I32 -> Str
Num.I32.is_zero : I32 -> Bool
Num.I32.is_negative : I32 -> Bool
Num.I32.is_positive : I32 -> Bool
Num.I32.is_eq : I32, I32 -> Bool
Num.I32.to_hash : I32, Hasher -> Hasher
Num.I32.is_gt : I32, I32 -> Bool
Num.I32.is_gte : I32, I32 -> Bool
Num.I32.is_lt : I32, I32 -> Bool
Num.I32.is_lte : I32, I32 -> Bool
Num.I32.compare : I32, I32 -> [LT, EQ, GT]
Num.I32.is_even : I32 -> Bool
Num.I32.is_odd : I32 -> Bool
Num.I32.is_multiple_of : I32, I32 -> Bool
Num.I32.max : I32, I32 -> I32
Num.I32.min : I32, I32 -> I32
Num.I32.negate : I32 -> I32
Num.I32.abs : I32 -> I32
Num.I32.plus : I32, I32 -> I32
Num.I32.add_try : I32, I32 -> Try(I32, [Overflow, ..])
Num.I32.range_exclusive : I32, I32 -> Iter(I32)
Num.I32.range_inclusive : I32, I32 -> Iter(I32)
Num.I32.plus_saturated : I32, I32 -> I32
Num.I32.minus : I32, I32 -> I32
Num.I32.sub_try : I32, I32 -> Try(I32, [Overflow, ..])
Num.I32.minus_saturated : I32, I32 -> I32
Num.I32.times : I32, I32 -> I32
Num.I32.mul_try : I32, I32 -> Try(I32, [Overflow, ..])
Num.I32.times_saturated : I32, I32 -> I32
Num.I32.pow : I32, I32 -> I32
Num.I32.pow_try : I32, I32 -> Try(I32, [Overflow, Underflow, ..])
Num.I32.div_by : I32, I32 -> I32
Num.I32.div_try : I32, I32 -> Try(I32, [DivByZero, Overflow, ..])
Num.I32.div_ceil_by : I32, I32 -> I32
Num.I32.div_ceil_try : I32, I32 -> Try(I32, [DivByZero, Overflow, ..])
Num.I32.div_floor_by : I32, I32 -> I32
Num.I32.div_trunc_by : I32, I32 -> I32
Num.I32.rem_by : I32, I32 -> I32
Num.I32.mod_by : I32, I32 -> I32
Num.I32.abs_diff : I32, I32 -> U32
Num.I32.shift_left_by : I32, U8 -> I32
Num.I32.shift_right_by : I32, U8 -> I32
Num.I32.shift_right_zf_by : I32, U8 -> I32
Num.I32.bitwise_and : I32, I32 -> I32
Num.I32.bitwise_or : I32, I32 -> I32
Num.I32.bitwise_xor : I32, I32 -> I32
Num.I32.bitwise_not : I32 -> I32
Num.I32.count_leading_zero_bits : I32 -> U8
Num.I32.count_trailing_zero_bits : I32 -> U8
Num.I32.count_one_bits : I32 -> U8
Num.I32.to : I32, I32 -> Iter(I32)
Num.I32.until : I32, I32 -> Iter(I32)
Num.I32.from_int_digits : List(U8) -> Try(I32, [OutOfRange])
Num.I32.from_numeral : Numeral -> Try(I32, [InvalidNumeral(Str)])
Num.I32.from_str : Str -> Try(I32, [BadNumStr, ..])
Num.I32.to_i8_wrap : I32 -> I8
Num.I32.to_i8_try : I32 -> Try(I8, [OutOfRange, ..])
Num.I32.to_i16_wrap : I32 -> I16
Num.I32.to_i16_try : I32 -> Try(I16, [OutOfRange, ..])
Num.I32.to_i32 : I32 -> I32
Num.I32.to_i32_try : I32 -> Try(I32, _never_fails)
Num.I32.to_i32_wrap : I32 -> I32
Num.I32.to_i64 : I32 -> I64
Num.I32.to_i128 : I32 -> I128
Num.I32.to_u8_wrap : I32 -> U8
Num.I32.to_u8_try : I32 -> Try(U8, [OutOfRange, ..])
Num.I32.to_u16_wrap : I32 -> U16
Num.I32.to_u16_try : I32 -> Try(U16, [OutOfRange, ..])
Num.I32.to_u32_wrap : I32 -> U32
Num.I32.to_u32_try : I32 -> Try(U32, [OutOfRange, ..])
Num.I32.to_u64_wrap : I32 -> U64
Num.I32.to_u64_try : I32 -> Try(U64, [OutOfRange, ..])
Num.I32.to_u128_wrap : I32 -> U128
Num.I32.to_u128_try : I32 -> Try(U128, [OutOfRange, ..])
Num.I32.to_f32 : I32 -> F32
Num.I32.to_f64 : I32 -> F64
Num.I32.to_dec : I32 -> Dec
Num.I32.encode : I32, fmt -> Try(encoded, err) where [fmt.encode_i32 : fmt, I32 -> Try(encoded, err)]
Num.I32.decode : src, fmt -> (Try(I32, err), src) where [fmt.decode_i32 : fmt, src -> (Try(I32, err), src)]
Num.U64
Num.U64.default : -> U64
Num.U64.highest : U64
Num.U64.lowest : U64
Num.U64.to_str : U64 -> Str
Num.U64.is_zero : U64 -> Bool
Num.U64.is_eq : U64, U64 -> Bool
Num.U64.to_hash : U64, Hasher -> Hasher
Num.U64.is_gt : U64, U64 -> Bool
Num.U64.is_gte : U64, U64 -> Bool
Num.U64.is_lt : U64, U64 -> Bool
Num.U64.is_lte : U64, U64 -> Bool
Num.U64.compare : U64, U64 -> [LT, EQ, GT]
Num.U64.is_even : U64 -> Bool
Num.U64.is_odd : U64 -> Bool
Num.U64.is_multiple_of : U64, U64 -> Bool
Num.U64.max : U64, U64 -> U64
Num.U64.min : U64, U64 -> U64
Num.U64.plus : U64, U64 -> U64
Num.U64.add_try : U64, U64 -> Try(U64, [Overflow, ..])
Num.U64.range_exclusive : U64, U64 -> Iter(U64)
Num.U64.range_inclusive : U64, U64 -> Iter(U64)
Num.U64.plus_saturated : U64, U64 -> U64
Num.U64.minus : U64, U64 -> U64
Num.U64.sub_try : U64, U64 -> Try(U64, [Overflow, ..])
Num.U64.minus_saturated : U64, U64 -> U64
Num.U64.times : U64, U64 -> U64
Num.U64.mul_try : U64, U64 -> Try(U64, [Overflow, ..])
Num.U64.times_saturated : U64, U64 -> U64
Num.U64.pow : U64, U64 -> U64
Num.U64.pow_try : U64, U64 -> Try(U64, [Overflow, ..])
Num.U64.div_by : U64, U64 -> U64
Num.U64.div_try : U64, U64 -> Try(U64, [DivByZero, ..])
Num.U64.div_ceil_by : U64, U64 -> U64
Num.U64.div_ceil_try : U64, U64 -> Try(U64, [DivByZero, ..])
Num.U64.div_floor_by : U64, U64 -> U64
Num.U64.div_trunc_by : U64, U64 -> U64
Num.U64.rem_by : U64, U64 -> U64
Num.U64.mod_by : U64, U64 -> U64
Num.U64.abs_diff : U64, U64 -> U64
Num.U64.shift_left_by : U64, U8 -> U64
Num.U64.shift_right_by : U64, U8 -> U64
Num.U64.shift_right_zf_by : U64, U8 -> U64
Num.U64.bitwise_and : U64, U64 -> U64
Num.U64.bitwise_or : U64, U64 -> U64
Num.U64.bitwise_xor : U64, U64 -> U64
Num.U64.bitwise_not : U64 -> U64
Num.U64.count_leading_zero_bits : U64 -> U8
Num.U64.count_trailing_zero_bits : U64 -> U8
Num.U64.count_one_bits : U64 -> U8
Num.U64.to : U64, U64 -> Iter(U64)
Num.U64.until : U64, U64 -> Iter(U64)
Num.U64.from_int_digits : List(U8) -> Try(U64, [OutOfRange])
Num.U64.from_numeral : Numeral -> Try(U64, [InvalidNumeral(Str)])
Num.U64.from_str : Str -> Try(U64, [BadNumStr, ..])
Num.U64.to_i8_wrap : U64 -> I8
Num.U64.to_i8_try : U64 -> Try(I8, [OutOfRange, ..])
Num.U64.to_i16_wrap : U64 -> I16
Num.U64.to_i16_try : U64 -> Try(I16, [OutOfRange, ..])
Num.U64.to_i32_wrap : U64 -> I32
Num.U64.to_i32_try : U64 -> Try(I32, [OutOfRange, ..])
Num.U64.to_i64_wrap : U64 -> I64
Num.U64.to_i64_try : U64 -> Try(I64, [OutOfRange, ..])
Num.U64.to_i128 : U64 -> I128
Num.U64.to_u8_wrap : U64 -> U8
Num.U64.to_u8_try : U64 -> Try(U8, [OutOfRange, ..])
Num.U64.to_u16_wrap : U64 -> U16
Num.U64.to_u16_try : U64 -> Try(U16, [OutOfRange, ..])
Num.U64.to_u32_wrap : U64 -> U32
Num.U64.to_u32_try : U64 -> Try(U32, [OutOfRange, ..])
Num.U64.to_u64 : U64 -> U64
Num.U64.to_u64_try : U64 -> Try(U64, _never_fails)
Num.U64.to_u64_wrap : U64 -> U64
Num.U64.to_u128 : U64 -> U128
Num.U64.to_f32 : U64 -> F32
Num.U64.to_f64 : U64 -> F64
Num.U64.to_dec : U64 -> Dec
Num.U64.encode : U64, fmt -> Try(encoded, err) where [fmt.encode_u64 : fmt, U64 -> Try(encoded, err)]
Num.U64.decode : src, fmt -> (Try(U64, err), src) where [fmt.decode_u64 : fmt, src -> (Try(U64, err), src)]
Num.I64
Num.I64.default : -> I64
Num.I64.highest : I64
Num.I64.lowest : I64
Num.I64.to_str : I64 -> Str
Num.I64.is_zero : I64 -> Bool
Num.I64.is_negative : I64 -> Bool
Num.I64.is_positive : I64 -> Bool
Num.I64.is_eq : I64, I64 -> Bool
Num.I64.to_hash : I64, Hasher -> Hasher
Num.I64.is_gt : I64, I64 -> Bool
Num.I64.is_gte : I64, I64 -> Bool
Num.I64.is_lt : I64, I64 -> Bool
Num.I64.is_lte : I64, I64 -> Bool
Num.I64.compare : I64, I64 -> [LT, EQ, GT]
Num.I64.is_even : I64 -> Bool
Num.I64.is_odd : I64 -> Bool
Num.I64.is_multiple_of : I64, I64 -> Bool
Num.I64.max : I64, I64 -> I64
Num.I64.min : I64, I64 -> I64
Num.I64.negate : I64 -> I64
Num.I64.abs : I64 -> I64
Num.I64.plus : I64, I64 -> I64
Num.I64.add_try : I64, I64 -> Try(I64, [Overflow, ..])
Num.I64.range_exclusive : I64, I64 -> Iter(I64)
Num.I64.range_inclusive : I64, I64 -> Iter(I64)
Num.I64.plus_saturated : I64, I64 -> I64
Num.I64.minus : I64, I64 -> I64
Num.I64.sub_try : I64, I64 -> Try(I64, [Overflow, ..])
Num.I64.minus_saturated : I64, I64 -> I64
Num.I64.times : I64, I64 -> I64
Num.I64.mul_try : I64, I64 -> Try(I64, [Overflow, ..])
Num.I64.times_saturated : I64, I64 -> I64
Num.I64.pow : I64, I64 -> I64
Num.I64.pow_try : I64, I64 -> Try(I64, [Overflow, Underflow, ..])
Num.I64.div_by : I64, I64 -> I64
Num.I64.div_try : I64, I64 -> Try(I64, [DivByZero, Overflow, ..])
Num.I64.div_ceil_by : I64, I64 -> I64
Num.I64.div_ceil_try : I64, I64 -> Try(I64, [DivByZero, Overflow, ..])
Num.I64.div_floor_by : I64, I64 -> I64
Num.I64.div_trunc_by : I64, I64 -> I64
Num.I64.rem_by : I64, I64 -> I64
Num.I64.mod_by : I64, I64 -> I64
Num.I64.abs_diff : I64, I64 -> U64
Num.I64.shift_left_by : I64, U8 -> I64
Num.I64.shift_right_by : I64, U8 -> I64
Num.I64.shift_right_zf_by : I64, U8 -> I64
Num.I64.bitwise_and : I64, I64 -> I64
Num.I64.bitwise_or : I64, I64 -> I64
Num.I64.bitwise_xor : I64, I64 -> I64
Num.I64.bitwise_not : I64 -> I64
Num.I64.count_leading_zero_bits : I64 -> U8
Num.I64.count_trailing_zero_bits : I64 -> U8
Num.I64.count_one_bits : I64 -> U8
Num.I64.to : I64, I64 -> Iter(I64)
Num.I64.until : I64, I64 -> Iter(I64)
Num.I64.from_int_digits : List(U8) -> Try(I64, [OutOfRange])
Num.I64.from_numeral : Numeral -> Try(I64, [InvalidNumeral(Str)])
Num.I64.from_str : Str -> Try(I64, [BadNumStr, ..])
Num.I64.to_i8_wrap : I64 -> I8
Num.I64.to_i8_try : I64 -> Try(I8, [OutOfRange, ..])
Num.I64.to_i16_wrap : I64 -> I16
Num.I64.to_i16_try : I64 -> Try(I16, [OutOfRange, ..])
Num.I64.to_i32_wrap : I64 -> I32
Num.I64.to_i32_try : I64 -> Try(I32, [OutOfRange, ..])
Num.I64.to_i64 : I64 -> I64
Num.I64.to_i64_try : I64 -> Try(I64, _never_fails)
Num.I64.to_i64_wrap : I64 -> I64
Num.I64.to_i128 : I64 -> I128
Num.I64.to_u8_wrap : I64 -> U8
Num.I64.to_u8_try : I64 -> Try(U8, [OutOfRange, ..])
Num.I64.to_u16_wrap : I64 -> U16
Num.I64.to_u16_try : I64 -> Try(U16, [OutOfRange, ..])
Num.I64.to_u32_wrap : I64 -> U32
Num.I64.to_u32_try : I64 -> Try(U32, [OutOfRange, ..])
Num.I64.to_u64_wrap : I64 -> U64
Num.I64.to_u64_try : I64 -> Try(U64, [OutOfRange, ..])
Num.I64.to_u128_wrap : I64 -> U128
Num.I64.to_u128_try : I64 -> Try(U128, [OutOfRange, ..])
Num.I64.to_f32 : I64 -> F32
Num.I64.to_f64 : I64 -> F64
Num.I64.to_dec : I64 -> Dec
Num.I64.encode : I64, fmt -> Try(encoded, err) where [fmt.encode_i64 : fmt, I64 -> Try(encoded, err)]
Num.I64.decode : src, fmt -> (Try(I64, err), src) where [fmt.decode_i64 : fmt, src -> (Try(I64, err), src)]
Num.U128
Num.U128.default : -> U128
Num.U128.highest : U128
Num.U128.lowest : U128
Num.U128.to_str : U128 -> Str
Num.U128.is_zero : U128 -> Bool
Num.U128.is_eq : U128, U128 -> Bool
Num.U128.to_hash : U128, Hasher -> Hasher
Num.U128.is_gt : U128, U128 -> Bool
Num.U128.is_gte : U128, U128 -> Bool
Num.U128.is_lt : U128, U128 -> Bool
Num.U128.is_lte : U128, U128 -> Bool
Num.U128.compare : U128, U128 -> [LT, EQ, GT]
Num.U128.is_even : U128 -> Bool
Num.U128.is_odd : U128 -> Bool
Num.U128.is_multiple_of : U128, U128 -> Bool
Num.U128.max : U128, U128 -> U128
Num.U128.min : U128, U128 -> U128
Num.U128.plus : U128, U128 -> U128
Num.U128.add_try : U128, U128 -> Try(U128, [Overflow, ..])
Num.U128.range_exclusive : U128, U128 -> Iter(U128)
Num.U128.range_inclusive : U128, U128 -> Iter(U128)
Num.U128.plus_saturated : U128, U128 -> U128
Num.U128.minus : U128, U128 -> U128
Num.U128.sub_try : U128, U128 -> Try(U128, [Overflow, ..])
Num.U128.minus_saturated : U128, U128 -> U128
Num.U128.times : U128, U128 -> U128
Num.U128.mul_try : U128, U128 -> Try(U128, [Overflow, ..])
Num.U128.times_saturated : U128, U128 -> U128
Num.U128.pow : U128, U128 -> U128
Num.U128.pow_try : U128, U128 -> Try(U128, [Overflow, ..])
Num.U128.div_by : U128, U128 -> U128
Num.U128.div_try : U128, U128 -> Try(U128, [DivByZero, ..])
Num.U128.div_ceil_by : U128, U128 -> U128
Num.U128.div_ceil_try : U128, U128 -> Try(U128, [DivByZero, ..])
Num.U128.div_floor_by : U128, U128 -> U128
Num.U128.div_trunc_by : U128, U128 -> U128
Num.U128.rem_by : U128, U128 -> U128
Num.U128.mod_by : U128, U128 -> U128
Num.U128.abs_diff : U128, U128 -> U128
Num.U128.shift_left_by : U128, U8 -> U128
Num.U128.shift_right_by : U128, U8 -> U128
Num.U128.shift_right_zf_by : U128, U8 -> U128
Num.U128.bitwise_and : U128, U128 -> U128
Num.U128.bitwise_or : U128, U128 -> U128
Num.U128.bitwise_xor : U128, U128 -> U128
Num.U128.bitwise_not : U128 -> U128
Num.U128.count_leading_zero_bits : U128 -> U8
Num.U128.count_trailing_zero_bits : U128 -> U8
Num.U128.count_one_bits : U128 -> U8
Num.U128.to : U128, U128 -> Iter(U128)
Num.U128.until : U128, U128 -> Iter(U128)
Num.U128.from_int_digits : List(U8) -> Try(U128, [OutOfRange])
Num.U128.from_numeral : Numeral -> Try(U128, [InvalidNumeral(Str)])
Num.U128.from_str : Str -> Try(U128, [BadNumStr, ..])
Num.U128.to_i8_wrap : U128 -> I8
Num.U128.to_i8_try : U128 -> Try(I8, [OutOfRange, ..])
Num.U128.to_i16_wrap : U128 -> I16
Num.U128.to_i16_try : U128 -> Try(I16, [OutOfRange, ..])
Num.U128.to_i32_wrap : U128 -> I32
Num.U128.to_i32_try : U128 -> Try(I32, [OutOfRange, ..])
Num.U128.to_i64_wrap : U128 -> I64
Num.U128.to_i64_try : U128 -> Try(I64, [OutOfRange, ..])
Num.U128.to_i128_wrap : U128 -> I128
Num.U128.to_i128_try : U128 -> Try(I128, [OutOfRange, ..])
Num.U128.to_u8_wrap : U128 -> U8
Num.U128.to_u8_try : U128 -> Try(U8, [OutOfRange, ..])
Num.U128.to_u16_wrap : U128 -> U16
Num.U128.to_u16_try : U128 -> Try(U16, [OutOfRange, ..])
Num.U128.to_u32_wrap : U128 -> U32
Num.U128.to_u32_try : U128 -> Try(U32, [OutOfRange, ..])
Num.U128.to_u64_wrap : U128 -> U64
Num.U128.to_u64_try : U128 -> Try(U64, [OutOfRange, ..])
Num.U128.to_u128 : U128 -> U128
Num.U128.to_u128_try : U128 -> Try(U128, _never_fails)
Num.U128.to_u128_wrap : U128 -> U128
Num.U128.to_f32 : U128 -> F32
Num.U128.to_f64 : U128 -> F64
Num.U128.to_dec_try : U128 -> Try(Dec, [OutOfRange])
Num.U128.encode : U128, fmt -> Try(encoded, err) where [fmt.encode_u128 : fmt, U128 -> Try(encoded, err)]
Num.U128.decode : src, fmt -> (Try(U128, err), src) where [fmt.decode_u128 : fmt, src -> (Try(U128, err), src)]
Num.I128
Num.I128.default : -> I128
Num.I128.highest : I128
Num.I128.lowest : I128
Num.I128.to_str : I128 -> Str
Num.I128.is_zero : I128 -> Bool
Num.I128.is_negative : I128 -> Bool
Num.I128.is_positive : I128 -> Bool
Num.I128.is_eq : I128, I128 -> Bool
Num.I128.to_hash : I128, Hasher -> Hasher
Num.I128.is_gt : I128, I128 -> Bool
Num.I128.is_gte : I128, I128 -> Bool
Num.I128.is_lt : I128, I128 -> Bool
Num.I128.is_lte : I128, I128 -> Bool
Num.I128.compare : I128, I128 -> [LT, EQ, GT]
Num.I128.is_even : I128 -> Bool
Num.I128.is_odd : I128 -> Bool
Num.I128.is_multiple_of : I128, I128 -> Bool
Num.I128.max : I128, I128 -> I128
Num.I128.min : I128, I128 -> I128
Num.I128.negate : I128 -> I128
Num.I128.abs : I128 -> I128
Num.I128.plus : I128, I128 -> I128
Num.I128.add_try : I128, I128 -> Try(I128, [Overflow, ..])
Num.I128.range_exclusive : I128, I128 -> Iter(I128)
Num.I128.range_inclusive : I128, I128 -> Iter(I128)
Num.I128.plus_saturated : I128, I128 -> I128
Num.I128.minus : I128, I128 -> I128
Num.I128.sub_try : I128, I128 -> Try(I128, [Overflow, ..])
Num.I128.minus_saturated : I128, I128 -> I128
Num.I128.times : I128, I128 -> I128
Num.I128.mul_try : I128, I128 -> Try(I128, [Overflow, ..])
Num.I128.times_saturated : I128, I128 -> I128
Num.I128.pow : I128, I128 -> I128
Num.I128.pow_try : I128, I128 -> Try(I128, [Overflow, Underflow, ..])
Num.I128.div_by : I128, I128 -> I128
Num.I128.div_try : I128, I128 -> Try(I128, [DivByZero, Overflow, ..])
Num.I128.div_ceil_by : I128, I128 -> I128
Num.I128.div_ceil_try : I128, I128 -> Try(I128, [DivByZero, Overflow, ..])
Num.I128.div_floor_by : I128, I128 -> I128
Num.I128.div_trunc_by : I128, I128 -> I128
Num.I128.rem_by : I128, I128 -> I128
Num.I128.mod_by : I128, I128 -> I128
Num.I128.abs_diff : I128, I128 -> U128
Num.I128.shift_left_by : I128, U8 -> I128
Num.I128.shift_right_by : I128, U8 -> I128
Num.I128.shift_right_zf_by : I128, U8 -> I128
Num.I128.bitwise_and : I128, I128 -> I128
Num.I128.bitwise_or : I128, I128 -> I128
Num.I128.bitwise_xor : I128, I128 -> I128
Num.I128.bitwise_not : I128 -> I128
Num.I128.count_leading_zero_bits : I128 -> U8
Num.I128.count_trailing_zero_bits : I128 -> U8
Num.I128.count_one_bits : I128 -> U8
Num.I128.to : I128, I128 -> Iter(I128)
Num.I128.until : I128, I128 -> Iter(I128)
Num.I128.from_int_digits : List(U8) -> Try(I128, [OutOfRange])
Num.I128.from_numeral : Numeral -> Try(I128, [InvalidNumeral(Str)])
Num.I128.from_str : Str -> Try(I128, [BadNumStr, ..])
Num.I128.to_i8_wrap : I128 -> I8
Num.I128.to_i8_try : I128 -> Try(I8, [OutOfRange, ..])
Num.I128.to_i16_wrap : I128 -> I16
Num.I128.to_i16_try : I128 -> Try(I16, [OutOfRange, ..])
Num.I128.to_i32_wrap : I128 -> I32
Num.I128.to_i32_try : I128 -> Try(I32, [OutOfRange, ..])
Num.I128.to_i64_wrap : I128 -> I64
Num.I128.to_i64_try : I128 -> Try(I64, [OutOfRange, ..])
Num.I128.to_i128 : I128 -> I128
Num.I128.to_i128_try : I128 -> Try(I128, _never_fails)
Num.I128.to_i128_wrap : I128 -> I128
Num.I128.to_u8_wrap : I128 -> U8
Num.I128.to_u8_try : I128 -> Try(U8, [OutOfRange, ..])
Num.I128.to_u16_wrap : I128 -> U16
Num.I128.to_u16_try : I128 -> Try(U16, [OutOfRange, ..])
Num.I128.to_u32_wrap : I128 -> U32
Num.I128.to_u32_try : I128 -> Try(U32, [OutOfRange, ..])
Num.I128.to_u64_wrap : I128 -> U64
Num.I128.to_u64_try : I128 -> Try(U64, [OutOfRange, ..])
Num.I128.to_u128_wrap : I128 -> U128
Num.I128.to_u128_try : I128 -> Try(U128, [OutOfRange, ..])
Num.I128.to_f32 : I128 -> F32
Num.I128.to_f64 : I128 -> F64
Num.I128.to_dec_try : I128 -> Try(Dec, [OutOfRange])
Num.I128.encode : I128, fmt -> Try(encoded, err) where [fmt.encode_i128 : fmt, I128 -> Try(encoded, err)]
Num.I128.decode : src, fmt -> (Try(I128, err), src) where [fmt.decode_i128 : fmt, src -> (Try(I128, err), src)]
Num.Dec
Num.Dec.default : -> Dec
Num.Dec.highest : Dec
Num.Dec.lowest : Dec
Num.Dec.e : Dec
Num.Dec.pi : Dec
Num.Dec.tau : Dec
Num.Dec.to_str : Dec -> Str
Num.Dec.is_zero : Dec -> Bool
Num.Dec.is_negative : Dec -> Bool
Num.Dec.is_positive : Dec -> Bool
Num.Dec.is_eq : Dec, Dec -> Bool
Num.Dec.to_hash : Dec, Hasher -> Hasher
Num.Dec.is_gt : Dec, Dec -> Bool
Num.Dec.is_gte : Dec, Dec -> Bool
Num.Dec.is_lt : Dec, Dec -> Bool
Num.Dec.is_lte : Dec, Dec -> Bool
Num.Dec.compare : Dec, Dec -> [LT, EQ, GT]
Num.Dec.max : Dec, Dec -> Dec
Num.Dec.min : Dec, Dec -> Dec
Num.Dec.negate : Dec -> Dec
Num.Dec.abs : Dec -> Dec
Num.Dec.plus : Dec, Dec -> Dec
Num.Dec.add_try : Dec, Dec -> Try(Dec, [Overflow, ..])
Num.Dec.range_exclusive : Dec, Dec -> Iter(Dec)
Num.Dec.range_inclusive : Dec, Dec -> Iter(Dec)
Num.Dec.plus_saturated : Dec, Dec -> Dec
Num.Dec.minus : Dec, Dec -> Dec
Num.Dec.sub_try : Dec, Dec -> Try(Dec, [Overflow, ..])
Num.Dec.minus_saturated : Dec, Dec -> Dec
Num.Dec.times : Dec, Dec -> Dec
Num.Dec.times_saturated : Dec, Dec -> Dec
Num.Dec.pow : Dec, Dec -> Dec
Num.Dec.sqrt : Dec -> Dec
Num.Dec.sqrt_try : Dec -> Try(Dec, [SqrtOfNegative, ..])
Num.Dec.sin : Dec -> Dec
Num.Dec.cos : Dec -> Dec
Num.Dec.tan : Dec -> Dec
Num.Dec.asin : Dec -> Dec
Num.Dec.acos : Dec -> Dec
Num.Dec.atan : Dec -> Dec
Num.Dec.div_by : Dec, Dec -> Dec
Num.Dec.div_trunc_by : Dec, Dec -> Dec
Num.Dec.div_floor_by : Dec, Dec -> Dec
Num.Dec.rem_by : Dec, Dec -> Dec
Num.Dec.abs_diff : Dec, Dec -> Dec
Num.Dec.round_to_i8 : Dec -> I8
Num.Dec.round_to_i16 : Dec -> I16
Num.Dec.round_to_i32 : Dec -> I32
Num.Dec.round_to_i64 : Dec -> I64
Num.Dec.round_to_i128 : Dec -> I128
Num.Dec.round_to_u8 : Dec -> U8
Num.Dec.round_to_u16 : Dec -> U16
Num.Dec.round_to_u32 : Dec -> U32
Num.Dec.round_to_u64 : Dec -> U64
Num.Dec.round_to_u128 : Dec -> U128
Num.Dec.floor_to_i8 : Dec -> I8
Num.Dec.floor_to_i16 : Dec -> I16
Num.Dec.floor_to_i32 : Dec -> I32
Num.Dec.floor_to_i64 : Dec -> I64
Num.Dec.floor_to_i128 : Dec -> I128
Num.Dec.floor_to_u8 : Dec -> U8
Num.Dec.floor_to_u16 : Dec -> U16
Num.Dec.floor_to_u32 : Dec -> U32
Num.Dec.floor_to_u64 : Dec -> U64
Num.Dec.floor_to_u128 : Dec -> U128
Num.Dec.ceiling_to_i8 : Dec -> I8
Num.Dec.ceiling_to_i16 : Dec -> I16
Num.Dec.ceiling_to_i32 : Dec -> I32
Num.Dec.ceiling_to_i64 : Dec -> I64
Num.Dec.ceiling_to_i128 : Dec -> I128
Num.Dec.ceiling_to_u8 : Dec -> U8
Num.Dec.ceiling_to_u16 : Dec -> U16
Num.Dec.ceiling_to_u32 : Dec -> U32
Num.Dec.ceiling_to_u64 : Dec -> U64
Num.Dec.ceiling_to_u128 : Dec -> U128
Num.Dec.from_int_digits : List(U8) -> Try(Dec, [OutOfRange])
Num.Dec.from_dec_digits : (List(U8), List(U8)) -> Try(Dec, [OutOfRange])
Num.Dec.from_numeral : Numeral -> Try(Dec, [InvalidNumeral(Str)])
Num.Dec.from_str : Str -> Try(Dec, [BadNumStr, ..])
Num.Dec.to_i8_wrap : Dec -> I8
Num.Dec.to_i8_try : Dec -> Try(I8, [OutOfRange])
Num.Dec.to_i16_wrap : Dec -> I16
Num.Dec.to_i16_try : Dec -> Try(I16, [OutOfRange])
Num.Dec.to_i32_wrap : Dec -> I32
Num.Dec.to_i32_try : Dec -> Try(I32, [OutOfRange])
Num.Dec.to_i64_wrap : Dec -> I64
Num.Dec.to_i64_try : Dec -> Try(I64, [OutOfRange])
Num.Dec.to_i128_wrap : Dec -> I128
Num.Dec.to_i128_try : Dec -> Try(I128, [OutOfRange])
Num.Dec.to_u8_wrap : Dec -> U8
Num.Dec.to_u8_try : Dec -> Try(U8, [OutOfRange])
Num.Dec.to_u16_wrap : Dec -> U16
Num.Dec.to_u16_try : Dec -> Try(U16, [OutOfRange])
Num.Dec.to_u32_wrap : Dec -> U32
Num.Dec.to_u32_try : Dec -> Try(U32, [OutOfRange])
Num.Dec.to_u64_wrap : Dec -> U64
Num.Dec.to_u64_try : Dec -> Try(U64, [OutOfRange])
Num.Dec.to_u128_wrap : Dec -> U128
Num.Dec.to_u128_try : Dec -> Try(U128, [OutOfRange])
Num.Dec.to_f32_wrap : Dec -> F32
Num.Dec.to_f32_try : Dec -> Try(F32, [OutOfRange])
Num.Dec.to_f64 : Dec -> F64
Num.Dec.to_dec : Dec -> Dec
Num.Dec.to_dec_try : Dec -> Try(Dec, _never_fails)
Num.Dec.to : Dec, Dec -> Iter(Dec)
Num.Dec.until : Dec, Dec -> Iter(Dec)
Num.Dec.encode : Dec, fmt -> Try(encoded, err) where [fmt.encode_dec : fmt, Dec -> Try(encoded, err)]
Num.Dec.decode : src, fmt -> (Try(Dec, err), src) where [fmt.decode_dec : fmt, src -> (Try(Dec, err), src)]
Num.F32
Num.F32.default : -> F32
Num.F32.highest : F32
Num.F32.lowest : F32
Num.F32.nan : F32
Num.F32.infinity : F32
Num.F32.e : F32
Num.F32.pi : F32
Num.F32.tau : F32
Num.F32.to_str : F32 -> Str
Num.F32.to_bits : F32 -> U32
Num.F32.from_bits : U32 -> F32
Num.F32.is_nan : F32 -> Bool
Num.F32.is_infinite : F32 -> Bool
Num.F32.is_finite : F32 -> Bool
Num.F32.is_zero : F32 -> Bool
Num.F32.is_float_eq : F32, F32 -> Bool
Num.F32.to_hash : F32, Hasher -> Hasher
Num.F32.is_negative : F32 -> Bool
Num.F32.is_positive : F32 -> Bool
Num.F32.is_gt : F32, F32 -> Bool
Num.F32.is_gte : F32, F32 -> Bool
Num.F32.is_lt : F32, F32 -> Bool
Num.F32.is_lte : F32, F32 -> Bool
Num.F32.max : F32, F32 -> F32
Num.F32.min : F32, F32 -> F32
Num.F32.negate : F32 -> F32
Num.F32.abs : F32 -> F32
Num.F32.sqrt : F32 -> F32
Num.F32.sqrt_try : F32 -> Try(F32, [SqrtOfNegative, ..])
Num.F32.pow : F32, F32 -> F32
Num.F32.sin : F32 -> F32
Num.F32.cos : F32 -> F32
Num.F32.tan : F32 -> F32
Num.F32.asin : F32 -> F32
Num.F32.acos : F32 -> F32
Num.F32.atan : F32 -> F32
Num.F32.plus : F32, F32 -> F32
Num.F32.minus : F32, F32 -> F32
Num.F32.times : F32, F32 -> F32
Num.F32.div_by : F32, F32 -> F32
Num.F32.div_trunc_by : F32, F32 -> F32
Num.F32.div_floor_by : F32, F32 -> F32
Num.F32.rem_by : F32, F32 -> F32
Num.F32.abs_diff : F32, F32 -> F32
Num.F32.round_to_i8 : F32 -> I8
Num.F32.round_to_i16 : F32 -> I16
Num.F32.round_to_i32 : F32 -> I32
Num.F32.round_to_i64 : F32 -> I64
Num.F32.round_to_i128 : F32 -> I128
Num.F32.round_to_u8 : F32 -> U8
Num.F32.round_to_u16 : F32 -> U16
Num.F32.round_to_u32 : F32 -> U32
Num.F32.round_to_u64 : F32 -> U64
Num.F32.round_to_u128 : F32 -> U128
Num.F32.floor_to_i8 : F32 -> I8
Num.F32.floor_to_i16 : F32 -> I16
Num.F32.floor_to_i32 : F32 -> I32
Num.F32.floor_to_i64 : F32 -> I64
Num.F32.floor_to_i128 : F32 -> I128
Num.F32.floor_to_u8 : F32 -> U8
Num.F32.floor_to_u16 : F32 -> U16
Num.F32.floor_to_u32 : F32 -> U32
Num.F32.floor_to_u64 : F32 -> U64
Num.F32.floor_to_u128 : F32 -> U128
Num.F32.ceiling_to_i8 : F32 -> I8
Num.F32.ceiling_to_i16 : F32 -> I16
Num.F32.ceiling_to_i32 : F32 -> I32
Num.F32.ceiling_to_i64 : F32 -> I64
Num.F32.ceiling_to_i128 : F32 -> I128
Num.F32.ceiling_to_u8 : F32 -> U8
Num.F32.ceiling_to_u16 : F32 -> U16
Num.F32.ceiling_to_u32 : F32 -> U32
Num.F32.ceiling_to_u64 : F32 -> U64
Num.F32.ceiling_to_u128 : F32 -> U128
Num.F32.from_int_digits : List(U8) -> Try(F32, [OutOfRange])
Num.F32.from_dec_digits : (List(U8), List(U8)) -> Try(F32, [OutOfRange])
Num.F32.from_numeral : Numeral -> Try(F32, [InvalidNumeral(Str)])
Num.F32.range_exclusive : F32, F32 -> Iter(F32)
Num.F32.range_inclusive : F32, F32 -> Iter(F32)
Num.F32.from_str : Str -> Try(F32, [BadNumStr, ..])
Num.F32.to_i8_wrap : F32 -> I8
Num.F32.to_i8_try : F32 -> Try(I8, [OutOfRange])
Num.F32.to_i16_wrap : F32 -> I16
Num.F32.to_i16_try : F32 -> Try(I16, [OutOfRange])
Num.F32.to_i32_wrap : F32 -> I32
Num.F32.to_i32_try : F32 -> Try(I32, [OutOfRange])
Num.F32.to_i64_wrap : F32 -> I64
Num.F32.to_i64_try : F32 -> Try(I64, [OutOfRange])
Num.F32.to_i128_wrap : F32 -> I128
Num.F32.to_i128_try : F32 -> Try(I128, [OutOfRange])
Num.F32.to_u8_wrap : F32 -> U8
Num.F32.to_u8_try : F32 -> Try(U8, [OutOfRange])
Num.F32.to_u16_wrap : F32 -> U16
Num.F32.to_u16_try : F32 -> Try(U16, [OutOfRange])
Num.F32.to_u32_wrap : F32 -> U32
Num.F32.to_u32_try : F32 -> Try(U32, [OutOfRange])
Num.F32.to_u64_wrap : F32 -> U64
Num.F32.to_u64_try : F32 -> Try(U64, [OutOfRange])
Num.F32.to_u128_wrap : F32 -> U128
Num.F32.to_u128_try : F32 -> Try(U128, [OutOfRange])
Num.F32.to_f32 : F32 -> F32
Num.F32.to_f32_wrap : F32 -> F32
Num.F32.to_f32_try : F32 -> Try(F32, _never_fails)
Num.F32.to_f64 : F32 -> F64
Num.F32.encode : F32, fmt -> Try(encoded, err) where [fmt.encode_f32 : fmt, F32 -> Try(encoded, err)]
Num.F32.decode : src, fmt -> (Try(F32, err), src) where [fmt.decode_f32 : fmt, src -> (Try(F32, err), src)]
Num.F64
Num.F64.default : -> F64
Num.F64.highest : F64
Num.F64.lowest : F64
Num.F64.nan : F64
Num.F64.infinity : F64
Num.F64.e : F64
Num.F64.pi : F64
Num.F64.tau : F64
Num.F64.to_str : F64 -> Str
Num.F64.to_bits : F64 -> U64
Num.F64.from_bits : U64 -> F64
Num.F64.is_nan : F64 -> Bool
Num.F64.is_infinite : F64 -> Bool
Num.F64.is_finite : F64 -> Bool
Num.F64.is_zero : F64 -> Bool
Num.F64.is_float_eq : F64, F64 -> Bool
Num.F64.to_hash : F64, Hasher -> Hasher
Num.F64.is_negative : F64 -> Bool
Num.F64.is_positive : F64 -> Bool
Num.F64.is_gt : F64, F64 -> Bool
Num.F64.is_gte : F64, F64 -> Bool
Num.F64.is_lt : F64, F64 -> Bool
Num.F64.is_lte : F64, F64 -> Bool
Num.F64.max : F64, F64 -> F64
Num.F64.min : F64, F64 -> F64
Num.F64.negate : F64 -> F64
Num.F64.abs : F64 -> F64
Num.F64.sqrt : F64 -> F64
Num.F64.sqrt_try : F64 -> Try(F64, [SqrtOfNegative, ..])
Num.F64.pow : F64, F64 -> F64
Num.F64.sin : F64 -> F64
Num.F64.cos : F64 -> F64
Num.F64.tan : F64 -> F64
Num.F64.asin : F64 -> F64
Num.F64.acos : F64 -> F64
Num.F64.atan : F64 -> F64
Num.F64.plus : F64, F64 -> F64
Num.F64.minus : F64, F64 -> F64
Num.F64.times : F64, F64 -> F64
Num.F64.div_by : F64, F64 -> F64
Num.F64.div_trunc_by : F64, F64 -> F64
Num.F64.div_floor_by : F64, F64 -> F64
Num.F64.rem_by : F64, F64 -> F64
Num.F64.abs_diff : F64, F64 -> F64
Num.F64.round_to_i8 : F64 -> I8
Num.F64.round_to_i16 : F64 -> I16
Num.F64.round_to_i32 : F64 -> I32
Num.F64.round_to_i64 : F64 -> I64
Num.F64.round_to_i128 : F64 -> I128
Num.F64.round_to_u8 : F64 -> U8
Num.F64.round_to_u16 : F64 -> U16
Num.F64.round_to_u32 : F64 -> U32
Num.F64.round_to_u64 : F64 -> U64
Num.F64.round_to_u128 : F64 -> U128
Num.F64.floor_to_i8 : F64 -> I8
Num.F64.floor_to_i16 : F64 -> I16
Num.F64.floor_to_i32 : F64 -> I32
Num.F64.floor_to_i64 : F64 -> I64
Num.F64.floor_to_i128 : F64 -> I128
Num.F64.floor_to_u8 : F64 -> U8
Num.F64.floor_to_u16 : F64 -> U16
Num.F64.floor_to_u32 : F64 -> U32
Num.F64.floor_to_u64 : F64 -> U64
Num.F64.floor_to_u128 : F64 -> U128
Num.F64.ceiling_to_i8 : F64 -> I8
Num.F64.ceiling_to_i16 : F64 -> I16
Num.F64.ceiling_to_i32 : F64 -> I32
Num.F64.ceiling_to_i64 : F64 -> I64
Num.F64.ceiling_to_i128 : F64 -> I128
Num.F64.ceiling_to_u8 : F64 -> U8
Num.F64.ceiling_to_u16 : F64 -> U16
Num.F64.ceiling_to_u32 : F64 -> U32
Num.F64.ceiling_to_u64 : F64 -> U64
Num.F64.ceiling_to_u128 : F64 -> U128
Num.F64.from_int_digits : List(U8) -> Try(F64, [OutOfRange])
Num.F64.from_dec_digits : (List(U8), List(U8)) -> Try(F64, [OutOfRange])
Num.F64.from_numeral : Numeral -> Try(F64, [InvalidNumeral(Str)])
Num.F64.range_exclusive : F64, F64 -> Iter(F64)
Num.F64.range_inclusive : F64, F64 -> Iter(F64)
Num.F64.from_str : Str -> Try(F64, [BadNumStr, ..])
Num.F64.to_i8_wrap : F64 -> I8
Num.F64.to_i8_try : F64 -> Try(I8, [OutOfRange])
Num.F64.to_i16_wrap : F64 -> I16
Num.F64.to_i16_try : F64 -> Try(I16, [OutOfRange])
Num.F64.to_i32_wrap : F64 -> I32
Num.F64.to_i32_try : F64 -> Try(I32, [OutOfRange])
Num.F64.to_i64_wrap : F64 -> I64
Num.F64.to_i64_try : F64 -> Try(I64, [OutOfRange])
Num.F64.to_i128_wrap : F64 -> I128
Num.F64.to_i128_try : F64 -> Try(I128, [OutOfRange])
Num.F64.to_u8_wrap : F64 -> U8
Num.F64.to_u8_try : F64 -> Try(U8, [OutOfRange])
Num.F64.to_u16_wrap : F64 -> U16
Num.F64.to_u16_try : F64 -> Try(U16, [OutOfRange])
Num.F64.to_u32_wrap : F64 -> U32
Num.F64.to_u32_try : F64 -> Try(U32, [OutOfRange])
Num.F64.to_u64_wrap : F64 -> U64
Num.F64.to_u64_try : F64 -> Try(U64, [OutOfRange])
Num.F64.to_u128_wrap : F64 -> U128
Num.F64.to_u128_try : F64 -> Try(U128, [OutOfRange])
Num.F64.to_f32_wrap : F64 -> F32
Num.F64.to_f32_try : F64 -> Try(F32, [OutOfRange])
Num.F64.to_f64 : F64 -> F64
Num.F64.to_f64_wrap : F64 -> F64
Num.F64.to_f64_try : F64 -> Try(F64, _never_fails)
Num.F64.encode : F64, fmt -> Try(encoded, err) where [fmt.encode_f64 : fmt, F64 -> Try(encoded, err)]
Num.F64.decode : src, fmt -> (Try(F64, err), src) where [fmt.decode_f64 : fmt, src -> (Try(F64, err), src)]
Set.is_eq : Set(a), Set(a) -> Bool where [a.is_eq : a, a -> Bool]
Set.to_hash : Set(a), Hasher -> Hasher where [a.to_hash : a, Hasher -> Hasher]
Set.empty : -> Set(_item)
Set.single : item -> Set(item)
Set.len : Set(_item) -> U64
Set.is_empty : Set(_item) -> Bool
Set.contains : Set(a), a -> Bool where [a.is_eq : a, a -> Bool]
Set.insert : Set(a), a -> Set(a) where [a.is_eq : a, a -> Bool]
Set.remove : Set(a), a -> Set(a) where [a.is_eq : a, a -> Bool]
Set.to_list : Set(a) -> List(a)
Set.from_list : List(a) -> Set(a) where [a.is_eq : a, a -> Bool]
Set.keep_if : Set(a), (a -> Bool) -> Set(a)
Set.drop_if : Set(a), (a -> Bool) -> Set(a)
Set.union : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool]
Set.intersection : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool]
Set.difference : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool]
Set.map : Set(a), (a -> b) -> Set(b) where [b.is_eq : b, b -> Bool]
Str.is_empty : Str -> Bool
Str.concat : Str, Str -> Str
Str.contains : Str, Str -> Bool
Str.trim : Str -> Str
Str.trim_start : Str -> Str
Str.trim_end : Str -> Str
Str.caseless_ascii_equals : Str, Str -> Bool
Str.with_ascii_lowercased : Str -> Str
Str.with_ascii_uppercased : Str -> Str
Str.starts_with : Str, Str -> Bool
Str.ends_with : Str, Str -> Bool
Str.repeat : Str, U64 -> Str
Str.with_prefix : Str, Str -> Str
Str.drop_prefix : Str, Str -> Str
Str.drop_prefix_caseless_ascii : Str, Str -> Try(Str, [NotFound])
Str.drop_suffix : Str, Str -> Str
Str.find_first : Str, Str -> Try({ before : Str, after : Str }, [NotFound])
Str.count_utf8_bytes : Str -> U64
Str.with_capacity : U64 -> Str
Str.reserve : Str, U64 -> Str
Str.release_excess_capacity : Str -> Str
Str.to_utf8 : Str -> List(U8)
Str.to_str : Str -> Str
Str.from_utf8_lossy : List(U8) -> Str
Str.from_utf8 : List(U8) -> Try(Str, [BadUtf8({ problem : Utf8Problem, index : U64 }), ..])
Str.from_quote : Str -> Try(Str, [BadQuotedBytes(Str)])
Str.from_interpolation : Str, Iter((Str, Str)) -> Str
Str.split_on : Str, Str -> List(Str)
Str.join_with : List(Str), Str -> Str
Str.is_eq : Str, Str -> Bool
Str.to_hash : Str, Hasher -> Hasher
Str.inspect : _val -> Str
Str.encode : Str, fmt -> Try(encoded, err) where [fmt.encode_str : fmt, Str -> Try(encoded, err)]
Str.decode : src, fmt -> (Try(Str, err), src) where [fmt.decode_str : fmt, src -> (Try(Str, err), src)]
Str.Utf8Problem := [InvalidStartByte, UnexpectedEndOfSequence, ExpectedContinuation, OverlongEncoding, CodepointTooLarge, EncodesSurrogateHalf]
Str.Utf8Problem.is_eq : Utf8Problem, Utf8Problem -> Bool
Stream.from_iter : Iter(item) -> Stream(item)
Stream.map : Stream(a), (a => b) -> Stream(b)
Stream.map! : Stream(a), (a => b) => Stream(b)
Stream.next! : Stream(item) => [One({ item : item, rest : Stream(item) }), Skip({ rest : Stream(item) }), Done]
Stream.size_hint : Stream(item) -> [Known(U64), Unknown]
Stream.collect! : Stream(item) => List(item)
Try.is_ok : Try(_ok, _err) -> Bool
Try.is_err : Try(_ok, _err) -> Bool
Try.from_interpolation : Str, Iter((interpolated, Str)) -> Try(ok, err) where [ok.from_interpolation : Str, Iter((interpolated, Str)) -> Try(ok, err)]
Try.ok_or : Try(ok, _err), ok -> ok
Try.err_or : Try(_ok, err), err -> err
Try.map_ok : Try(a, err), (a -> b) -> Try(b, err)
Try.map_ok! : Try(a, err), (a => b) => Try(b, err)
Try.map_err : Try(ok, a), (a -> b) -> Try(ok, b)
Try.map_err! : Try(ok, a), (a => b) => Try(ok, b)
Try.is_eq : Try(ok, err), Try(ok, err) -> Bool where [ok.is_eq : ok, ok -> Bool, err.is_eq : err, err -> Bool]
Try.to_hash : Try(ok, err), Hasher -> Hasher where [ok.to_hash : ok, Hasher -> Hasher, err.to_hash : err, Hasher -> Hasher]

Language Reference
Tutorial
FAQ

Records

Structural Records

TODO

Nominal Records

TODO

Empty Record

TODO

Made by people who like to make nice things.