Struct Int 

pub struct Int(/* private fields */);

A Python integer literal. Represents both small (fits in an i64) and large integers.

Implementations

impl Int

pub const ZERO: Int

pub const ONE: Int

pub fn from_str_radix( number: &str, radix: u32, token: &str, ) -> Result<Self, ParseIntError>

Parse an Int from a string with a given radix, like 0x95D.

Takes, as input, the numerical portion (95D), the parsed base (16), and the entire token (0x95D).

pub fn as_u8(&self) -> Option<u8>

Return the Int as an u8, if it can be represented as that data type.

pub fn as_u16(&self) -> Option<u16>

Return the Int as an u16, if it can be represented as that data type.

pub fn as_u32(&self) -> Option<u32>

Return the Int as an u32, if it can be represented as that data type.

pub const fn as_u64(&self) -> Option<u64>

Return the Int as an u64, if it can be represented as that data type.

pub fn as_usize(&self) -> Option<usize>

Return the Int as an usize, if it can be represented as that data type.

pub fn as_i8(&self) -> Option<i8>

Return the Int as an i8, if it can be represented as that data type.

pub fn as_i16(&self) -> Option<i16>

Return the Int as an i16, if it can be represented as that data type.

pub fn as_i32(&self) -> Option<i32>

Return the Int as an i32, if it can be represented as that data type.

pub fn as_i64(&self) -> Option<i64>

Return the Int as an i64, if it can be represented as that data type.

Trait Implementations

impl Clone for Int

fn clone(&self) -> Int

Returns a duplicate 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 Display for Int

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

Formats the value using the given formatter.

impl From<u16> for Int

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Int

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Int

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Int

fn from(value: u8) -> Self

Converts to this type from the input type.

impl FromStr for Int

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse an Int from a string.

type Err = ParseIntError

The associated error which can be returned from parsing.

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 PartialEq<i16> for Int

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<i32> for Int

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<i8> for Int

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u16> for Int

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u32> for Int

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u8> for Int

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for Int

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Int

impl StructuralPartialEq for Int