Struct readable::Int

pub struct Int(_, _);

Human readable signed integer.

Creation

For i8, i16, i32, i64, isize or any NonZeroI8 variant:

• Use Int::from

f32 or f64 inputs will work, but:

• Fractional parts will be ignored
• Under/overflows will return Int::unknown
• Special floats like f64::NAN will return Int::unknown

For u8 and other unsigned integers:

• You can use Int::from for anything under u32
• You need to use Int::try_from for anything above u32
• Int::unknown will be returned on error

Cloning

Copy is available.

The actual string used internally is not a String, but a 26 byte array buffer, literally: [u8; 26].

The documentation will still refer to the inner buffer as a String. Anything returned will also be a String.

let a = Int::from(100_000);

// Copy 'a', use 'b'.
let b = a;
assert!(b == 100_000);

// We can still use 'a'
assert!(a == 100_000);

Float Errors

• Inputting f64::NAN returns Int::unknown
• Inputting f64::INFINITY returns Int::unknown
• Inputting f64::NEG_INFINITY returns Int::unknown

To disable checks for these, (you are sure you don’t have NaN’s), enable the ignore_nan_inf feature flag.

Math

These operators are overloaded. They will always output a new Self:

• Add +
• Sub -
• Div /
• Mul *
• Rem %

They can either be:

• Combined with another Self: Int::from(1) + Int::from(1)
• Or with the inner number itself: Int::from(1) + 1

They also have the same panic!() behavior on overflow as the normal ones, because internally, it is just calling .inner() $OPERATOR $NUMBER.

assert!(Int::from(10) + 10 == Int::from(20));
assert!(Int::from(10) - 10 == Int::from(0));
assert!(Int::from(10) / 10 == Int::from(1));
assert!(Int::from(10) * 10 == Int::from(100));
assert!(Int::from(10) % 10 == Int::from(0));

Overflow example:

let n = Int::from(i64::MAX) + i64::MAX;

Examples

// From u32.
assert!(Int::from(1_000_u32)     == "1,000");
assert!(Int::from(100_000_u32)   == "100,000");
assert!(Int::from(1_000_000_u32) == "1,000,000");

// From signed integers.
assert!(Int::from(-1_000)   == "-1,000");
assert!(Int::from(-100_000) == "-100,000");
assert!(Int::from(-100_000) == "-100,000");

// From floats.
assert!(Int::from(-1.0)        == "-1");
assert!(Int::from(1_000.123)   == "1,000");
assert!(Int::from(100_000.123) == "100,000");
assert!(Int::from(100_000.123) == "100,000");

Implementations

impl Int

pub fn as_str(&self) -> &str

Return a borrowed str without consuming Self.

pub fn as_bytes(&self) -> &[u8]

Returns the valid byte slice of the inner String

These bytes can always safely be used for std::str::from_utf8_unchecked.

pub fn to_vec(&self) -> Vec<u8>

Return the bytes of the inner String as a Vec

pub fn into_vec(self) -> Vec<u8>

Return the bytes of the inner String as a Vec, consuming Self

pub const fn inner(&self) -> i64

Returns the inner number.

pub fn into_string(self) -> String

Consumes Self, returning the inner String.

pub fn into_raw(self) -> (i64, String)

Consumes Self, returning the inner parts.

pub fn head(&self, len: usize) -> &str

Return the first len bytes of this str.

This will return the full str if the len is longer than the actual inner str.

Since all readable types happen to only contain ASCII characters, all char’s are equal to 1 byte.

let date = Date::from_str("2021-12-11").unwrap();

assert!(date.head(5) == "2021-");

pub fn head_dot(&self, len: usize) -> String

Same as Self::head but returns a String ending with ...

This will return the full string without ... if the len is longer than the actual inner str.

let date = Date::from_str("2021-12-11").unwrap();

assert!(date.head_dot(4) == "2021...");

pub fn tail(&self, len: usize) -> &str

Return the last len bytes of this str.

This will return the full str if the len is longer than the actual inner str.

Since all readable types happen to only contain ASCII characters, all char’s are equal to 1 byte.

let date = Date::from_str("2021-12-11").unwrap();

assert!(date.tail(5) == "12-11");

pub fn tail_dot(&self, len: usize) -> String

Same as Self::tail but returns a String starting with ...

This will return the full string without ... if the len is longer than the actual inner str.

let date = Date::from_str("2021-12-11").unwrap();

assert!(date.tail_dot(5) == "...12-11");

pub fn head_tail(&self, head: usize, tail: usize) -> String

Return the first head bytes and last tail bytes of this string separated with ....

Since all readable types happen to only contain ASCII characters, all char’s are equal to 1 byte.

let date = Date::from_str("2021-12-11").unwrap();

assert!(date.head_tail(3, 2) == "202...11");
assert!(date.head_tail(3, 3) == "202...-11");
assert!(date.head_tail(3, 5) == "202...12-11");

pub const fn len(&self) -> usize

The length of the inner String

pub const fn is_empty(&self) -> bool

If the inner String is empty or not

pub const fn to_buf(&self) -> [u8; 26]

Return the full inner buffer that represents the String.

These are guaranteed to be valid UTF-8 bytes.

Not all bytes are necessarily used, however. To find the valid portion of the string, use Self::len.

let u           = Unsigned::from(123_u8);
let buffer      = u.to_buf();
let valid_bytes = &buffer[0..u.len()];

// SAFETY: These bytes are always be valid UTF-8.
unsafe {
    let specified = std::str::from_utf8_unchecked(&valid_bytes);
    let all_bytes = std::str::from_utf8_unchecked(&buffer);

    // Bunch of trailing `\0\0\0`'s at the end.
    assert!(all_bytes != "123");
    assert!(specified == "123");
}

pub const fn into_buf(self) -> [u8; 26]

Same as Self::to_buf but consumes self.

pub const fn as_buf(&self) -> &[u8; 26]

Same as Self::to_buf but returns a borrowed array.

pub const fn to_buf_parts(&self) -> ([u8; 26], usize)

Same as Self::to_buf but returns the length as well.

pub const fn into_buf_parts(self) -> ([u8; 26], usize)

Same as Self::into_buf but returns the length as well.

pub const fn zero() -> Self

assert!(Int::zero() == 0);

pub const fn unknown() -> Self

assert!(Int::unknown() == UNKNOWN);

Trait Implementations

impl Add<&Int> for Int

type Output = Int

The resulting type after applying the + operator.

fn add(self, other: &Int) -> Self

Performs the + operation.

impl Add<&Int> for i64

type Output = i64

The resulting type after applying the + operator.

fn add(self, other: &Int) -> Self

Performs the + operation.

impl Add<&i64> for Int

type Output = Int

The resulting type after applying the + operator.

fn add(self, other: &i64) -> Self

Performs the + operation.

impl Add<Int> for Int

type Output = Int

The resulting type after applying the + operator.

fn add(self, other: Int) -> Self

Performs the + operation.

impl Add<Int> for i64

type Output = i64

The resulting type after applying the + operator.

fn add(self, other: Int) -> Self

Performs the + operation.

impl Add<i64> for Int

type Output = Int

The resulting type after applying the + operator.

fn add(self, other: i64) -> Self

Performs the + operation.

impl<'__de> BorrowDecode<'__de> for Int

fn borrow_decode<__D: BorrowDecoder<'__de>>( decoder: &mut __D ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for Int

fn clone(&self) -> Int

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Int

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode for Int

fn decode<__D: Decoder>(decoder: &mut __D) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Default for Int

fn default() -> Self

Calls Self::zero

impl<'de> Deserialize<'de> for Int

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Int

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<&Int> for Int

type Output = Int

The resulting type after applying the / operator.

fn div(self, other: &Int) -> Self

Performs the / operation.

impl Div<&Int> for i64

type Output = i64

The resulting type after applying the / operator.

fn div(self, other: &Int) -> Self

Performs the / operation.

impl Div<&i64> for Int

type Output = Int

The resulting type after applying the / operator.

fn div(self, other: &i64) -> Self

Performs the / operation.

impl Div<Int> for Int

type Output = Int

The resulting type after applying the / operator.

fn div(self, other: Int) -> Self

Performs the / operation.

impl Div<Int> for i64

type Output = i64

The resulting type after applying the / operator.

fn div(self, other: Int) -> Self

Performs the / operation.

impl Div<i64> for Int

type Output = Int

The resulting type after applying the / operator.

fn div(self, other: i64) -> Self

Performs the / operation.

impl Encode for Int

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl From<&NonZeroI16> for Int

fn from(int: &NonZeroI16) -> Self

Converts to this type from the input type.

impl From<&NonZeroI32> for Int

fn from(int: &NonZeroI32) -> Self

Converts to this type from the input type.

impl From<&NonZeroI64> for Int

fn from(int: &NonZeroI64) -> Self

Converts to this type from the input type.

impl From<&NonZeroI8> for Int

fn from(int: &NonZeroI8) -> Self

Converts to this type from the input type.

impl From<&NonZeroIsize> for Int

fn from(int: &NonZeroIsize) -> Self

Converts to this type from the input type.

impl From<NonZeroI16> for Int

fn from(int: NonZeroI16) -> Self

Converts to this type from the input type.

impl From<NonZeroI32> for Int

fn from(int: NonZeroI32) -> Self

Converts to this type from the input type.

impl From<NonZeroI64> for Int

fn from(int: NonZeroI64) -> Self

Converts to this type from the input type.

impl From<NonZeroI8> for Int

fn from(int: NonZeroI8) -> Self

Converts to this type from the input type.

impl From<NonZeroIsize> for Int

fn from(int: NonZeroIsize) -> Self

Converts to this type from the input type.

impl From<f32> for Int

This will silently return Self::unknown if the input float is NAN, INFINITY, or under/overflows.

fn from(float: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Int

This will silently return Self::unknown if the input float is NAN, INFINITY, or under/overflows.

fn from(float: f64) -> Self

Converts to this type from the input type.

impl From<i16> for Int

fn from(int: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Int

fn from(int: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Int

fn from(int: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Int

fn from(int: i8) -> Self

Converts to this type from the input type.

impl From<isize> for Int

fn from(int: isize) -> Self

Converts to this type from the input type.

impl From<u16> for Int

fn from(int: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Int

fn from(int: u32) -> Self

Converts to this type from the input type.

impl From<u8> for Int

fn from(int: u8) -> Self

Converts to this type from the input type.

impl Hash for Int

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul<&Int> for Int

type Output = Int

The resulting type after applying the * operator.

fn mul(self, other: &Int) -> Self

Performs the * operation.

impl Mul<&Int> for i64

type Output = i64

The resulting type after applying the * operator.

fn mul(self, other: &Int) -> Self

Performs the * operation.

impl Mul<&i64> for Int

type Output = Int

The resulting type after applying the * operator.

fn mul(self, other: &i64) -> Self

Performs the * operation.

impl Mul<Int> for Int

type Output = Int

The resulting type after applying the * operator.

fn mul(self, other: Int) -> Self

Performs the * operation.

impl Mul<Int> for i64

type Output = i64

The resulting type after applying the * operator.

fn mul(self, other: Int) -> Self

Performs the * operation.

impl Mul<i64> for Int

type Output = Int

The resulting type after applying the * operator.

fn mul(self, other: i64) -> Self

Performs the * operation.

impl Ord for Int

fn cmp(&self, other: &Int) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<&Int> for i64

fn eq(&self, other: &&Int) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&Int> for str

fn eq(&self, other: &&Int) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&str> for Int

fn eq(&self, other: &&str) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Int> for Int

fn eq(&self, other: &Int) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Int> for i64

fn eq(&self, other: &Int) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Int> for str

fn eq(&self, other: &Int) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i64> for &Int

fn eq(&self, other: &i64) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i64> for Int

fn eq(&self, other: &i64) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for Int

fn eq(&self, other: &str) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<&Int> for i64

fn partial_cmp(&self, other: &&Int) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<&Int> for str

fn partial_cmp(&self, other: &&Int) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<&str> for Int

fn partial_cmp(&self, other: &&str) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Int> for Int

fn partial_cmp(&self, other: &Int) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Int> for i64

fn partial_cmp(&self, other: &Int) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Int> for str

fn partial_cmp(&self, other: &Int) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i64> for &Int

fn partial_cmp(&self, other: &i64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i64> for Int

fn partial_cmp(&self, other: &i64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<str> for Int

fn partial_cmp(&self, other: &str) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rem<&Int> for Int

type Output = Int

The resulting type after applying the % operator.

fn rem(self, other: &Int) -> Self

Performs the % operation.

impl Rem<&Int> for i64

type Output = i64

The resulting type after applying the % operator.

fn rem(self, other: &Int) -> Self

Performs the % operation.

impl Rem<&i64> for Int

type Output = Int

The resulting type after applying the % operator.

fn rem(self, other: &i64) -> Self

Performs the % operation.

impl Rem<Int> for Int

type Output = Int

The resulting type after applying the % operator.

fn rem(self, other: Int) -> Self

Performs the % operation.

impl Rem<Int> for i64

type Output = i64

The resulting type after applying the % operator.

fn rem(self, other: Int) -> Self

Performs the % operation.

impl Rem<i64> for Int

type Output = Int

The resulting type after applying the % operator.

fn rem(self, other: i64) -> Self

Performs the % operation.

impl Serialize for Int

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<&Int> for Int

type Output = Int

The resulting type after applying the - operator.

fn sub(self, other: &Int) -> Self

Performs the - operation.

impl Sub<&Int> for i64

type Output = i64

The resulting type after applying the - operator.

fn sub(self, other: &Int) -> Self

Performs the - operation.

impl Sub<&i64> for Int

type Output = Int

The resulting type after applying the - operator.

fn sub(self, other: &i64) -> Self

Performs the - operation.

impl Sub<Int> for Int

type Output = Int

The resulting type after applying the - operator.

fn sub(self, other: Int) -> Self

Performs the - operation.

impl Sub<Int> for i64

type Output = i64

The resulting type after applying the - operator.

fn sub(self, other: Int) -> Self

Performs the - operation.

impl Sub<i64> for Int

type Output = Int

The resulting type after applying the - operator.

fn sub(self, other: i64) -> Self

Performs the - operation.

impl TryFrom<&NonZeroU16> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: &NonZeroU16) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<&NonZeroU32> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: &NonZeroU32) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<&NonZeroU64> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: &NonZeroU64) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<&NonZeroU8> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: &NonZeroU8) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<&NonZeroUsize> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: &NonZeroUsize) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<NonZeroU16> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: NonZeroU16) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<NonZeroU32> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: NonZeroU32) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<NonZeroU64> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: NonZeroU64) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<NonZeroU8> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: NonZeroU8) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<NonZeroUsize> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: NonZeroUsize) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<u64> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: u64) -> Result<Self, Self>

Performs the conversion.

impl TryFrom<usize> for Int

This will return Self::unknown wrapped in Result::Err if the conversion fails.

type Error = Int

The type returned in the event of a conversion error.

fn try_from(num: usize) -> Result<Self, Self>

Performs the conversion.

impl Copy for Int

impl Eq for Int

impl StructuralEq for Int

impl StructuralPartialEq for Int