Enum Int 

pub enum Int {
    Small(i64),
    Big(Box<BigInt>),
}

A Python integer.

Cloning a big one copies its digits. That is deliberate rather than a missing Rc: keeping this plain data is what makes it Send and Sync, a literal is cloned about as often as it is created, and the object model this is a stand-in for gives every heap value a refcounted header of its own.

Variants

Small(i64)

Fits in a machine word, which nearly everything does.

Big(Box<BigInt>)

Does not. Never holds a value that would fit in Int::Small.

Implementations

impl Int

pub const ZERO: Self

Zero.

pub const fn from_i64(value: i64) -> Self

An integer from a machine word.

pub fn from_big(value: BigInt) -> Self

An integer from a bignum, narrowed if it fits.

Every path that can produce a big value goes through here, which is what keeps the invariant that a Big never holds something an i64 could.

pub fn parse(digits: &str, radix: u32) -> Option<Self>

The digits of an integer literal in some radix, without a sign.

Returns None if digits is empty or holds anything the radix does not allow, which is a caller bug rather than a syntax error: the lexer has already decided what a number looks like. Leading zeros are not an error, since 007 and 7 are the same integer.

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

This as a machine word, if it fits.

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

This as a usize, for the places an index or a count is wanted.

pub fn to_f64(&self) -> Option<f64>

This as a double, or None when it is too large to be one.

Python raises OverflowError for that case rather than returning infinity, which is why this is not a plain f64.

pub fn is_zero(&self) -> bool

Whether this is zero, which is also whether it is falsey.

pub fn is_negative(&self) -> bool

pub fn to_big(&self) -> BigInt

This as a bignum, whichever arm it is in.

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

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

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

pub fn bitand(&self, other: &Self) -> Self

pub fn bitor(&self, other: &Self) -> Self

pub fn bitxor(&self, other: &Self) -> Self

pub fn neg(&self) -> Self

-self.

pub fn invert(&self) -> Self

~self, which is -self - 1 on the infinite two’s complement.

pub fn abs(&self) -> Self

pub fn floor_div(&self, other: &Self) -> Result<Self, DivideByZero>

self // other, flooring toward negative infinity as Python does.

pub fn modulo(&self, other: &Self) -> Result<Self, DivideByZero>

self % other, taking the sign of the divisor as Python does.

pub fn div_mod(&self, other: &Self) -> Result<(Self, Self), DivideByZero>

divmod(self, other), which is the quotient and remainder together.

Both are derived from the truncating pair rather than taken from the underlying type, so a change of arm cannot change the answer. The correction is the same in either arm: when the remainder is non-zero and its sign disagrees with the divisor, the truncating quotient is one too large and the remainder is a whole divisor short.

pub fn true_div(&self, other: &Self) -> Result<Option<f64>, DivideByZero>

self / other, which in Python is always a float.

None means the true quotient is out of range for a double, which Python reports as OverflowError rather than as infinity.

pub fn pow(&self, exponent: &Self) -> Option<Self>

self ** exponent for a non-negative exponent.

None for a negative one, which Python answers with a float rather than an integer, and for an exponent so large that the result could not be held. Both are the caller’s to turn into the right thing.

pub fn shl(&self, places: &Self) -> Option<Self>

self << places, which needs a non-negative count.

None for a negative one, which Python reports as ValueError: negative shift count, and for a count large enough that the result would not fit in memory.

pub fn shr(&self, places: &Self) -> Option<Self>

self >> places, which needs a non-negative count.

An arithmetic shift, so a negative number shifted far enough lands on -1 rather than on zero, which is what flooring means here.

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 Eq for Int

impl From<BigInt> for Int

fn from(value: BigInt) -> Self

Converts to this type from the input type.

impl From<i64> for Int

fn from(value: i64) -> Self

Converts to this type from the input type.

impl Ord for Int

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Int

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Int

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl StructuralPartialEq for Int