# Primitive Type i32 [−]

The 32-bit signed integer type.

## Methods

`impl i32`

`const fn min_value() -> i32`

1.0.0

Returns the smallest value that can be represented by this integer type.

`const fn max_value() -> i32`

1.0.0

Returns the largest value that can be represented by this integer type.

`fn from_str_radix(src: &str, radix: u32) -> Result<i32, ParseIntError>`

1.0.0

Converts a string slice in a given base to an integer.

Leading and trailing whitespace represent an error.

# Examples

Basic usage:

fn main() { assert_eq!(i32::from_str_radix("A", 16), Ok(10)); }assert_eq!(i32::from_str_radix("A", 16), Ok(10));

`fn count_ones(self) -> u32`

1.0.0

Returns the number of ones in the binary representation of `self`

.

# Examples

Basic usage:

fn main() { let n = -0b1000_0000i8; assert_eq!(n.count_ones(), 1); }let n = -0b1000_0000i8; assert_eq!(n.count_ones(), 1);

`fn count_zeros(self) -> u32`

1.0.0

Returns the number of zeros in the binary representation of `self`

.

# Examples

Basic usage:

fn main() { let n = -0b1000_0000i8; assert_eq!(n.count_zeros(), 7); }let n = -0b1000_0000i8; assert_eq!(n.count_zeros(), 7);

`fn leading_zeros(self) -> u32`

1.0.0

Returns the number of leading zeros in the binary representation
of `self`

.

# Examples

Basic usage:

fn main() { let n = -1i16; assert_eq!(n.leading_zeros(), 0); }let n = -1i16; assert_eq!(n.leading_zeros(), 0);

`fn trailing_zeros(self) -> u32`

1.0.0

Returns the number of trailing zeros in the binary representation
of `self`

.

# Examples

Basic usage:

fn main() { let n = -4i8; assert_eq!(n.trailing_zeros(), 2); }let n = -4i8; assert_eq!(n.trailing_zeros(), 2);

`fn rotate_left(self, n: u32) -> i32`

1.0.0

Shifts the bits to the left by a specified amount, `n`

,
wrapping the truncated bits to the end of the resulting integer.

# Examples

Basic usage:

fn main() { let n = 0x0123456789ABCDEFi64; let m = -0x76543210FEDCBA99i64; assert_eq!(n.rotate_left(32), m); }let n = 0x0123456789ABCDEFi64; let m = -0x76543210FEDCBA99i64; assert_eq!(n.rotate_left(32), m);

`fn rotate_right(self, n: u32) -> i32`

1.0.0

Shifts the bits to the right by a specified amount, `n`

,
wrapping the truncated bits to the beginning of the resulting
integer.

# Examples

Basic usage:

fn main() { let n = 0x0123456789ABCDEFi64; let m = -0xFEDCBA987654322i64; assert_eq!(n.rotate_right(4), m); }let n = 0x0123456789ABCDEFi64; let m = -0xFEDCBA987654322i64; assert_eq!(n.rotate_right(4), m);

`fn swap_bytes(self) -> i32`

1.0.0

Reverses the byte order of the integer.

# Examples

Basic usage:

fn main() { let n = 0x0123456789ABCDEFi64; let m = -0x1032547698BADCFFi64; assert_eq!(n.swap_bytes(), m); }let n = 0x0123456789ABCDEFi64; let m = -0x1032547698BADCFFi64; assert_eq!(n.swap_bytes(), m);

`fn from_be(x: i32) -> i32`

1.0.0

Converts an integer from big endian to the target's endianness.

On big endian this is a no-op. On little endian the bytes are swapped.

# Examples

Basic usage:

fn main() { let n = 0x0123456789ABCDEFi64; if cfg!(target_endian = "big") { assert_eq!(i64::from_be(n), n) } else { assert_eq!(i64::from_be(n), n.swap_bytes()) } }let n = 0x0123456789ABCDEFi64; if cfg!(target_endian = "big") { assert_eq!(i64::from_be(n), n) } else { assert_eq!(i64::from_be(n), n.swap_bytes()) }

`fn from_le(x: i32) -> i32`

1.0.0

Converts an integer from little endian to the target's endianness.

On little endian this is a no-op. On big endian the bytes are swapped.

# Examples

Basic usage:

fn main() { let n = 0x0123456789ABCDEFi64; if cfg!(target_endian = "little") { assert_eq!(i64::from_le(n), n) } else { assert_eq!(i64::from_le(n), n.swap_bytes()) } }let n = 0x0123456789ABCDEFi64; if cfg!(target_endian = "little") { assert_eq!(i64::from_le(n), n) } else { assert_eq!(i64::from_le(n), n.swap_bytes()) }

`fn to_be(self) -> i32`

1.0.0

Converts `self`

to big endian from the target's endianness.

On big endian this is a no-op. On little endian the bytes are swapped.

# Examples

Basic usage:

fn main() { let n = 0x0123456789ABCDEFi64; if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) } }let n = 0x0123456789ABCDEFi64; if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }

`fn to_le(self) -> i32`

1.0.0

Converts `self`

to little endian from the target's endianness.

On little endian this is a no-op. On big endian the bytes are swapped.

# Examples

Basic usage:

fn main() { let n = 0x0123456789ABCDEFi64; if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) } }let n = 0x0123456789ABCDEFi64; if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }

`fn checked_add(self, other: i32) -> Option<i32>`

1.0.0

Checked integer addition. Computes `self + other`

, returning `None`

if overflow occurred.

# Examples

Basic usage:

fn main() { assert_eq!(7i16.checked_add(32760), Some(32767)); assert_eq!(8i16.checked_add(32760), None); }assert_eq!(7i16.checked_add(32760), Some(32767)); assert_eq!(8i16.checked_add(32760), None);

`fn checked_sub(self, other: i32) -> Option<i32>`

1.0.0

Checked integer subtraction. Computes `self - other`

, returning
`None`

if underflow occurred.

# Examples

Basic usage:

fn main() { assert_eq!((-127i8).checked_sub(1), Some(-128)); assert_eq!((-128i8).checked_sub(1), None); }assert_eq!((-127i8).checked_sub(1), Some(-128)); assert_eq!((-128i8).checked_sub(1), None);

`fn checked_mul(self, other: i32) -> Option<i32>`

1.0.0

Checked integer multiplication. Computes `self * other`

, returning
`None`

if underflow or overflow occurred.

# Examples

Basic usage:

fn main() { assert_eq!(6i8.checked_mul(21), Some(126)); assert_eq!(6i8.checked_mul(22), None); }assert_eq!(6i8.checked_mul(21), Some(126)); assert_eq!(6i8.checked_mul(22), None);

`fn checked_div(self, other: i32) -> Option<i32>`

1.0.0

Checked integer division. Computes `self / other`

, returning `None`

if `other == 0`

or the operation results in underflow or overflow.

# Examples

Basic usage:

fn main() { assert_eq!((-127i8).checked_div(-1), Some(127)); assert_eq!((-128i8).checked_div(-1), None); assert_eq!((1i8).checked_div(0), None); }assert_eq!((-127i8).checked_div(-1), Some(127)); assert_eq!((-128i8).checked_div(-1), None); assert_eq!((1i8).checked_div(0), None);

`fn checked_rem(self, other: i32) -> Option<i32>`

1.7.0

Checked integer remainder. Computes `self % other`

, returning `None`

if `other == 0`

or the operation results in underflow or overflow.

# Examples

Basic usage:

fn main() { use std::i32; assert_eq!(5i32.checked_rem(2), Some(1)); assert_eq!(5i32.checked_rem(0), None); assert_eq!(i32::MIN.checked_rem(-1), None); }use std::i32; assert_eq!(5i32.checked_rem(2), Some(1)); assert_eq!(5i32.checked_rem(0), None); assert_eq!(i32::MIN.checked_rem(-1), None);

`fn checked_neg(self) -> Option<i32>`

1.7.0

Checked negation. Computes `-self`

, returning `None`

if `self == MIN`

.

# Examples

Basic usage:

fn main() { use std::i32; assert_eq!(5i32.checked_neg(), Some(-5)); assert_eq!(i32::MIN.checked_neg(), None); }use std::i32; assert_eq!(5i32.checked_neg(), Some(-5)); assert_eq!(i32::MIN.checked_neg(), None);

`fn checked_shl(self, rhs: u32) -> Option<i32>`

1.7.0

Checked shift left. Computes `self << rhs`

, returning `None`

if `rhs`

is larger than or equal to the number of bits in `self`

.

# Examples

Basic usage:

fn main() { assert_eq!(0x10i32.checked_shl(4), Some(0x100)); assert_eq!(0x10i32.checked_shl(33), None); }assert_eq!(0x10i32.checked_shl(4), Some(0x100)); assert_eq!(0x10i32.checked_shl(33), None);

`fn checked_shr(self, rhs: u32) -> Option<i32>`

1.7.0

Checked shift right. Computes `self >> rhs`

, returning `None`

if `rhs`

is larger than or equal to the number of bits in `self`

.

# Examples

Basic usage:

fn main() { assert_eq!(0x10i32.checked_shr(4), Some(0x1)); assert_eq!(0x10i32.checked_shr(33), None); }assert_eq!(0x10i32.checked_shr(4), Some(0x1)); assert_eq!(0x10i32.checked_shr(33), None);

`fn saturating_add(self, other: i32) -> i32`

1.0.0

Saturating integer addition. Computes `self + other`

, saturating at
the numeric bounds instead of overflowing.

# Examples

Basic usage:

fn main() { assert_eq!(100i8.saturating_add(1), 101); assert_eq!(100i8.saturating_add(127), 127); }assert_eq!(100i8.saturating_add(1), 101); assert_eq!(100i8.saturating_add(127), 127);

`fn saturating_sub(self, other: i32) -> i32`

1.0.0

Saturating integer subtraction. Computes `self - other`

, saturating
at the numeric bounds instead of overflowing.

# Examples

Basic usage:

fn main() { assert_eq!(100i8.saturating_sub(127), -27); assert_eq!((-100i8).saturating_sub(127), -128); }assert_eq!(100i8.saturating_sub(127), -27); assert_eq!((-100i8).saturating_sub(127), -128);

`fn saturating_mul(self, other: i32) -> i32`

1.7.0

Saturating integer multiplication. Computes `self * other`

,
saturating at the numeric bounds instead of overflowing.

# Examples

Basic usage:

fn main() { use std::i32; assert_eq!(100i32.saturating_mul(127), 12700); assert_eq!((1i32 << 23).saturating_mul(1 << 23), i32::MAX); assert_eq!((-1i32 << 23).saturating_mul(1 << 23), i32::MIN); }use std::i32; assert_eq!(100i32.saturating_mul(127), 12700); assert_eq!((1i32 << 23).saturating_mul(1 << 23), i32::MAX); assert_eq!((-1i32 << 23).saturating_mul(1 << 23), i32::MIN);

`fn wrapping_add(self, rhs: i32) -> i32`

1.0.0

Wrapping (modular) addition. Computes `self + other`

,
wrapping around at the boundary of the type.

# Examples

Basic usage:

fn main() { assert_eq!(100i8.wrapping_add(27), 127); assert_eq!(100i8.wrapping_add(127), -29); }assert_eq!(100i8.wrapping_add(27), 127); assert_eq!(100i8.wrapping_add(127), -29);

`fn wrapping_sub(self, rhs: i32) -> i32`

1.0.0

Wrapping (modular) subtraction. Computes `self - other`

,
wrapping around at the boundary of the type.

# Examples

Basic usage:

fn main() { assert_eq!(0i8.wrapping_sub(127), -127); assert_eq!((-2i8).wrapping_sub(127), 127); }assert_eq!(0i8.wrapping_sub(127), -127); assert_eq!((-2i8).wrapping_sub(127), 127);

`fn wrapping_mul(self, rhs: i32) -> i32`

1.0.0

Wrapping (modular) multiplication. Computes `self * other`

, wrapping around at the boundary of the type.

# Examples

Basic usage:

fn main() { assert_eq!(10i8.wrapping_mul(12), 120); assert_eq!(11i8.wrapping_mul(12), -124); }assert_eq!(10i8.wrapping_mul(12), 120); assert_eq!(11i8.wrapping_mul(12), -124);

`fn wrapping_div(self, rhs: i32) -> i32`

1.2.0

Wrapping (modular) division. Computes `self / other`

,
wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one
divides `MIN / -1`

on a signed type (where `MIN`

is the
negative minimal value for the type); this is equivalent
to `-MIN`

, a positive value that is too large to represent
in the type. In such a case, this function returns `MIN`

itself.

# Panics

This function will panic if `rhs`

is 0.

# Examples

Basic usage:

fn main() { assert_eq!(100u8.wrapping_div(10), 10); assert_eq!((-128i8).wrapping_div(-1), -128); }assert_eq!(100u8.wrapping_div(10), 10); assert_eq!((-128i8).wrapping_div(-1), -128);

`fn wrapping_rem(self, rhs: i32) -> i32`

1.2.0

Wrapping (modular) remainder. Computes `self % other`

,
wrapping around at the boundary of the type.

Such wrap-around never actually occurs mathematically;
implementation artifacts make `x % y`

invalid for `MIN / -1`

on a signed type (where `MIN`

is the negative
minimal value). In such a case, this function returns `0`

.

# Panics

This function will panic if `rhs`

is 0.

# Examples

Basic usage:

fn main() { assert_eq!(100i8.wrapping_rem(10), 0); assert_eq!((-128i8).wrapping_rem(-1), 0); }assert_eq!(100i8.wrapping_rem(10), 0); assert_eq!((-128i8).wrapping_rem(-1), 0);

`fn wrapping_neg(self) -> i32`

1.2.0

Wrapping (modular) negation. Computes `-self`

,
wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one
negates `MIN`

on a signed type (where `MIN`

is the
negative minimal value for the type); this is a positive
value that is too large to represent in the type. In such
a case, this function returns `MIN`

itself.

# Examples

Basic usage:

fn main() { assert_eq!(100i8.wrapping_neg(), -100); assert_eq!((-128i8).wrapping_neg(), -128); }assert_eq!(100i8.wrapping_neg(), -100); assert_eq!((-128i8).wrapping_neg(), -128);

`fn wrapping_shl(self, rhs: u32) -> i32`

1.2.0

Panic-free bitwise shift-left; yields `self << mask(rhs)`

,
where `mask`

removes any high-order bits of `rhs`

that
would cause the shift to exceed the bitwidth of the type.

Note that this is *not* the same as a rotate-left; the
RHS of a wrapping shift-left is restricted to the range
of the type, rather than the bits shifted out of the LHS
being returned to the other end. The primitive integer
types all implement a `rotate_left`

function, which may
be what you want instead.

# Examples

Basic usage:

fn main() { assert_eq!((-1i8).wrapping_shl(7), -128); assert_eq!((-1i8).wrapping_shl(8), -1); }assert_eq!((-1i8).wrapping_shl(7), -128); assert_eq!((-1i8).wrapping_shl(8), -1);

`fn wrapping_shr(self, rhs: u32) -> i32`

1.2.0

Panic-free bitwise shift-right; yields `self >> mask(rhs)`

,
where `mask`

removes any high-order bits of `rhs`

that
would cause the shift to exceed the bitwidth of the type.

Note that this is *not* the same as a rotate-right; the
RHS of a wrapping shift-right is restricted to the range
of the type, rather than the bits shifted out of the LHS
being returned to the other end. The primitive integer
types all implement a `rotate_right`

function, which may
be what you want instead.

# Examples

Basic usage:

fn main() { assert_eq!((-128i8).wrapping_shr(7), -1); assert_eq!((-128i8).wrapping_shr(8), -128); }assert_eq!((-128i8).wrapping_shr(7), -1); assert_eq!((-128i8).wrapping_shr(8), -128);

`fn overflowing_add(self, rhs: i32) -> (i32, bool)`

1.7.0

Calculates `self`

+ `rhs`

Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

# Examples

Basic usage

fn main() { use std::i32; assert_eq!(5i32.overflowing_add(2), (7, false)); assert_eq!(i32::MAX.overflowing_add(1), (i32::MIN, true)); }use std::i32; assert_eq!(5i32.overflowing_add(2), (7, false)); assert_eq!(i32::MAX.overflowing_add(1), (i32::MIN, true));

`fn overflowing_sub(self, rhs: i32) -> (i32, bool)`

1.7.0

Calculates `self`

- `rhs`

Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

# Examples

Basic usage

fn main() { use std::i32; assert_eq!(5i32.overflowing_sub(2), (3, false)); assert_eq!(i32::MIN.overflowing_sub(1), (i32::MAX, true)); }use std::i32; assert_eq!(5i32.overflowing_sub(2), (3, false)); assert_eq!(i32::MIN.overflowing_sub(1), (i32::MAX, true));

`fn overflowing_mul(self, rhs: i32) -> (i32, bool)`

1.7.0

Calculates the multiplication of `self`

and `rhs`

.

Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

# Examples

Basic usage

fn main() { assert_eq!(5i32.overflowing_mul(2), (10, false)); assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true)); }assert_eq!(5i32.overflowing_mul(2), (10, false)); assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));

`fn overflowing_div(self, rhs: i32) -> (i32, bool)`

1.7.0

Calculates the divisor when `self`

is divided by `rhs`

.

Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then self is returned.

# Panics

This function will panic if `rhs`

is 0.

# Examples

Basic usage

fn main() { use std::i32; assert_eq!(5i32.overflowing_div(2), (2, false)); assert_eq!(i32::MIN.overflowing_div(-1), (i32::MIN, true)); }use std::i32; assert_eq!(5i32.overflowing_div(2), (2, false)); assert_eq!(i32::MIN.overflowing_div(-1), (i32::MIN, true));

`fn overflowing_rem(self, rhs: i32) -> (i32, bool)`

1.7.0

Calculates the remainder when `self`

is divided by `rhs`

.

Returns a tuple of the remainder after dividing along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then 0 is returned.

# Panics

This function will panic if `rhs`

is 0.

# Examples

Basic usage

fn main() { use std::i32; assert_eq!(5i32.overflowing_rem(2), (1, false)); assert_eq!(i32::MIN.overflowing_rem(-1), (0, true)); }use std::i32; assert_eq!(5i32.overflowing_rem(2), (1, false)); assert_eq!(i32::MIN.overflowing_rem(-1), (0, true));

`fn overflowing_neg(self) -> (i32, bool)`

1.7.0

Negates self, overflowing if this is equal to the minimum value.

Returns a tuple of the negated version of self along with a boolean
indicating whether an overflow happened. If `self`

is the minimum
value (e.g. `i32::MIN`

for values of type `i32`

), then the minimum
value will be returned again and `true`

will be returned for an
overflow happening.

# Examples

Basic usage

fn main() { use std::i32; assert_eq!(2i32.overflowing_neg(), (-2, false)); assert_eq!(i32::MIN.overflowing_neg(), (i32::MIN, true)); }use std::i32; assert_eq!(2i32.overflowing_neg(), (-2, false)); assert_eq!(i32::MIN.overflowing_neg(), (i32::MIN, true));

`fn overflowing_shl(self, rhs: u32) -> (i32, bool)`

1.7.0

Shifts self left by `rhs`

bits.

Returns a tuple of the shifted version of self along with a boolean indicating whether the shift value was larger than or equal to the number of bits. If the shift value is too large, then value is masked (N-1) where N is the number of bits, and this value is then used to perform the shift.

# Examples

Basic usage

fn main() { assert_eq!(0x10i32.overflowing_shl(4), (0x100, false)); assert_eq!(0x10i32.overflowing_shl(36), (0x100, true)); }assert_eq!(0x10i32.overflowing_shl(4), (0x100, false)); assert_eq!(0x10i32.overflowing_shl(36), (0x100, true));

`fn overflowing_shr(self, rhs: u32) -> (i32, bool)`

1.7.0

Shifts self right by `rhs`

bits.

Returns a tuple of the shifted version of self along with a boolean indicating whether the shift value was larger than or equal to the number of bits. If the shift value is too large, then value is masked (N-1) where N is the number of bits, and this value is then used to perform the shift.

# Examples

Basic usage

fn main() { assert_eq!(0x10i32.overflowing_shr(4), (0x1, false)); assert_eq!(0x10i32.overflowing_shr(36), (0x1, true)); }assert_eq!(0x10i32.overflowing_shr(4), (0x1, false)); assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));

`fn pow(self, exp: u32) -> i32`

1.0.0

Raises self to the power of `exp`

, using exponentiation by squaring.

# Examples

Basic usage:

fn main() { let x: i32 = 2; // or any other integer type assert_eq!(x.pow(4), 16); }let x: i32 = 2; // or any other integer type assert_eq!(x.pow(4), 16);

`fn abs(self) -> i32`

1.0.0

Computes the absolute value of `self`

.

# Overflow behavior

The absolute value of `i32::min_value()`

cannot be represented as an
`i32`

, and attempting to calculate it will cause an overflow. This
means that code in debug mode will trigger a panic on this case and
optimized code will return `i32::min_value()`

without a panic.

# Examples

Basic usage:

fn main() { assert_eq!(10i8.abs(), 10); assert_eq!((-10i8).abs(), 10); }assert_eq!(10i8.abs(), 10); assert_eq!((-10i8).abs(), 10);

`fn signum(self) -> i32`

1.0.0

Returns a number representing sign of `self`

.

`0`

if the number is zero`1`

if the number is positive`-1`

if the number is negative

# Examples

Basic usage:

fn main() { assert_eq!(10i8.signum(), 1); assert_eq!(0i8.signum(), 0); assert_eq!((-10i8).signum(), -1); }assert_eq!(10i8.signum(), 1); assert_eq!(0i8.signum(), 0); assert_eq!((-10i8).signum(), -1);

`fn is_positive(self) -> bool`

1.0.0

Returns `true`

if `self`

is positive and `false`

if the number
is zero or negative.

# Examples

Basic usage:

fn main() { assert!(10i8.is_positive()); assert!(!(-10i8).is_positive()); }assert!(10i8.is_positive()); assert!(!(-10i8).is_positive());

`fn is_negative(self) -> bool`

1.0.0

Returns `true`

if `self`

is negative and `false`

if the number
is zero or positive.

# Examples

Basic usage:

fn main() { assert!((-10i8).is_negative()); assert!(!10i8.is_negative()); }assert!((-10i8).is_negative()); assert!(!10i8.is_negative());

## Trait Implementations

`impl Zero for i32`

`impl One for i32`

`impl FromStr for i32`

1.0.0

`type Err = ParseIntError`

The associated error which can be returned from parsing.

`fn from_str(src: &str) -> Result<i32, ParseIntError>`

Parses a string `s`

to return a value of this type. Read more

`impl TryFrom<i8> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: i8) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<i16> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: i16) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<i32> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: i32) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<i64> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: i64) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<isize> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: isize) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<u8> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: u8) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<u16> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: u16) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<u32> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: u32) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<u64> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: u64) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl TryFrom<usize> for i32`

1.0.0

`type Err = TryFromIntError`

The type returned in the event of a conversion error.

`fn try_from(u: usize) -> Result<i32, TryFromIntError>`

Performs the conversion.

`impl From<i8> for i32`

1.5.0

`impl From<i16> for i32`

1.5.0

`impl From<u8> for i32`

1.5.0

`impl From<u16> for i32`

1.5.0

`impl Zeroable for i32`

`impl Add<i32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `+`

operator

`fn add(self, other: i32) -> i32`

The method for the `+`

operator

`impl<'a> Add<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `+`

operator

`fn add(self, other: i32) -> i32::Output`

The method for the `+`

operator

`impl<'a> Add<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `+`

operator

`fn add(self, other: &'a i32) -> i32::Output`

The method for the `+`

operator

`impl<'a, 'b> Add<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `+`

operator

`fn add(self, other: &'a i32) -> i32::Output`

The method for the `+`

operator

`impl Sub<i32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `-`

operator

`fn sub(self, other: i32) -> i32`

The method for the `-`

operator

`impl<'a> Sub<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `-`

operator

`fn sub(self, other: i32) -> i32::Output`

The method for the `-`

operator

`impl<'a> Sub<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `-`

operator

`fn sub(self, other: &'a i32) -> i32::Output`

The method for the `-`

operator

`impl<'a, 'b> Sub<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `-`

operator

`fn sub(self, other: &'a i32) -> i32::Output`

The method for the `-`

operator

`impl Mul<i32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `*`

operator

`fn mul(self, other: i32) -> i32`

The method for the `*`

operator

`impl<'a> Mul<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `*`

operator

`fn mul(self, other: i32) -> i32::Output`

The method for the `*`

operator

`impl<'a> Mul<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `*`

operator

`fn mul(self, other: &'a i32) -> i32::Output`

The method for the `*`

operator

`impl<'a, 'b> Mul<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `*`

operator

`fn mul(self, other: &'a i32) -> i32::Output`

The method for the `*`

operator

`impl Div<i32> for i32`

1.0.0

This operation rounds towards zero, truncating any fractional part of the exact result.

`type Output = i32`

The resulting type after applying the `/`

operator

`fn div(self, other: i32) -> i32`

The method for the `/`

operator

`impl<'a> Div<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `/`

operator

`fn div(self, other: i32) -> i32::Output`

The method for the `/`

operator

`impl<'a> Div<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `/`

operator

`fn div(self, other: &'a i32) -> i32::Output`

The method for the `/`

operator

`impl<'a, 'b> Div<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `/`

operator

`fn div(self, other: &'a i32) -> i32::Output`

The method for the `/`

operator

`impl Rem<i32> for i32`

1.0.0

This operation satisfies `n % d == n - (n / d) * d`

. The
result has the same sign as the left operand.

`type Output = i32`

The resulting type after applying the `%`

operator

`fn rem(self, other: i32) -> i32`

The method for the `%`

operator

`impl<'a> Rem<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `%`

operator

`fn rem(self, other: i32) -> i32::Output`

The method for the `%`

operator

`impl<'a> Rem<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `%`

operator

`fn rem(self, other: &'a i32) -> i32::Output`

The method for the `%`

operator

`impl<'a, 'b> Rem<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `%`

operator

`fn rem(self, other: &'a i32) -> i32::Output`

The method for the `%`

operator

`impl Neg for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `-`

operator

`fn neg(self) -> i32`

The method for the unary `-`

operator

`impl<'a> Neg for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `-`

operator

`fn neg(self) -> i32::Output`

The method for the unary `-`

operator

`impl Not for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `!`

operator

`fn not(self) -> i32`

The method for the unary `!`

operator

`impl<'a> Not for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `!`

operator

`fn not(self) -> i32::Output`

The method for the unary `!`

operator

`impl BitAnd<i32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `&`

operator

`fn bitand(self, rhs: i32) -> i32`

The method for the `&`

operator

`impl<'a> BitAnd<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `&`

operator

`fn bitand(self, other: i32) -> i32::Output`

The method for the `&`

operator

`impl<'a> BitAnd<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `&`

operator

`fn bitand(self, other: &'a i32) -> i32::Output`

The method for the `&`

operator

`impl<'a, 'b> BitAnd<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `&`

operator

`fn bitand(self, other: &'a i32) -> i32::Output`

The method for the `&`

operator

`impl BitOr<i32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `|`

operator

`fn bitor(self, rhs: i32) -> i32`

The method for the `|`

operator

`impl<'a> BitOr<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `|`

operator

`fn bitor(self, other: i32) -> i32::Output`

The method for the `|`

operator

`impl<'a> BitOr<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `|`

operator

`fn bitor(self, other: &'a i32) -> i32::Output`

The method for the `|`

operator

`impl<'a, 'b> BitOr<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `|`

operator

`fn bitor(self, other: &'a i32) -> i32::Output`

The method for the `|`

operator

`impl BitXor<i32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `^`

operator

`fn bitxor(self, other: i32) -> i32`

The method for the `^`

operator

`impl<'a> BitXor<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `^`

operator

`fn bitxor(self, other: i32) -> i32::Output`

The method for the `^`

operator

`impl<'a> BitXor<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `^`

operator

`fn bitxor(self, other: &'a i32) -> i32::Output`

The method for the `^`

operator

`impl<'a, 'b> BitXor<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `^`

operator

`fn bitxor(self, other: &'a i32) -> i32::Output`

The method for the `^`

operator

`impl Shl<u8> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: u8) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<u8> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: u8) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a u8> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a u8) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a u8> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a u8) -> i32::Output`

The method for the `<<`

operator

`impl Shl<u16> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: u16) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<u16> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: u16) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a u16> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a u16) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a u16> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a u16) -> i32::Output`

The method for the `<<`

operator

`impl Shl<u32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: u32) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<u32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: u32) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a u32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a u32) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a u32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a u32) -> i32::Output`

The method for the `<<`

operator

`impl Shl<u64> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: u64) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<u64> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: u64) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a u64> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a u64) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a u64> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a u64) -> i32::Output`

The method for the `<<`

operator

`impl Shl<usize> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: usize) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<usize> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: usize) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a usize> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a usize) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a usize> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a usize) -> i32::Output`

The method for the `<<`

operator

`impl Shl<i8> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: i8) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<i8> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: i8) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a i8> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a i8) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a i8> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a i8) -> i32::Output`

The method for the `<<`

operator

`impl Shl<i16> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: i16) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<i16> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: i16) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a i16> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a i16) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a i16> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a i16) -> i32::Output`

The method for the `<<`

operator

`impl Shl<i32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: i32) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: i32) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a i32) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a i32) -> i32::Output`

The method for the `<<`

operator

`impl Shl<i64> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: i64) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<i64> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: i64) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a i64> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a i64) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a i64> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a i64) -> i32::Output`

The method for the `<<`

operator

`impl Shl<isize> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `<<`

operator

`fn shl(self, other: isize) -> i32`

The method for the `<<`

operator

`impl<'a> Shl<isize> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: isize) -> i32::Output`

The method for the `<<`

operator

`impl<'a> Shl<&'a isize> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a isize) -> i32::Output`

The method for the `<<`

operator

`impl<'a, 'b> Shl<&'a isize> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `<<`

operator

`fn shl(self, other: &'a isize) -> i32::Output`

The method for the `<<`

operator

`impl Shr<u8> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: u8) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<u8> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: u8) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a u8> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a u8) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a u8> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a u8) -> i32::Output`

The method for the `>>`

operator

`impl Shr<u16> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: u16) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<u16> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: u16) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a u16> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a u16) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a u16> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a u16) -> i32::Output`

The method for the `>>`

operator

`impl Shr<u32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: u32) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<u32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: u32) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a u32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a u32) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a u32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a u32) -> i32::Output`

The method for the `>>`

operator

`impl Shr<u64> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: u64) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<u64> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: u64) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a u64> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a u64) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a u64> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a u64) -> i32::Output`

The method for the `>>`

operator

`impl Shr<usize> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: usize) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<usize> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: usize) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a usize> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a usize) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a usize> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a usize) -> i32::Output`

The method for the `>>`

operator

`impl Shr<i8> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: i8) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<i8> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: i8) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a i8> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a i8) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a i8> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a i8) -> i32::Output`

The method for the `>>`

operator

`impl Shr<i16> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: i16) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<i16> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: i16) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a i16> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a i16) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a i16> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a i16) -> i32::Output`

The method for the `>>`

operator

`impl Shr<i32> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: i32) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<i32> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: i32) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a i32> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a i32) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a i32> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a i32) -> i32::Output`

The method for the `>>`

operator

`impl Shr<i64> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: i64) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<i64> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: i64) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a i64> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a i64) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a i64> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a i64) -> i32::Output`

The method for the `>>`

operator

`impl Shr<isize> for i32`

1.0.0

`type Output = i32`

The resulting type after applying the `>>`

operator

`fn shr(self, other: isize) -> i32`

The method for the `>>`

operator

`impl<'a> Shr<isize> for &'a i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: isize) -> i32::Output`

The method for the `>>`

operator

`impl<'a> Shr<&'a isize> for i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a isize) -> i32::Output`

The method for the `>>`

operator

`impl<'a, 'b> Shr<&'a isize> for &'b i32`

1.0.0

`type Output = i32::Output`

The resulting type after applying the `>>`

operator

`fn shr(self, other: &'a isize) -> i32::Output`

The method for the `>>`

operator

`impl AddAssign<i32> for i32`

1.8.0

`fn add_assign(&mut self, other: i32)`

The method for the `+=`

operator

`impl SubAssign<i32> for i32`

1.8.0

`fn sub_assign(&mut self, other: i32)`

The method for the `-=`

operator

`impl MulAssign<i32> for i32`

1.8.0

`fn mul_assign(&mut self, other: i32)`

The method for the `*=`

operator

`impl DivAssign<i32> for i32`

1.8.0

`fn div_assign(&mut self, other: i32)`

The method for the `/=`

operator

`impl RemAssign<i32> for i32`

1.8.0

`fn rem_assign(&mut self, other: i32)`

The method for the `%=`

operator

`impl BitAndAssign<i32> for i32`

1.8.0

`fn bitand_assign(&mut self, other: i32)`

The method for the `&`

operator

`impl BitOrAssign<i32> for i32`

1.8.0

`fn bitor_assign(&mut self, other: i32)`

The method for the `|=`

operator

`impl BitXorAssign<i32> for i32`

1.8.0

`fn bitxor_assign(&mut self, other: i32)`

The method for the `^=`

operator

`impl ShlAssign<u8> for i32`

1.8.0

`fn shl_assign(&mut self, other: u8)`

The method for the `<<=`

operator

`impl ShlAssign<u16> for i32`

1.8.0

`fn shl_assign(&mut self, other: u16)`

The method for the `<<=`

operator

`impl ShlAssign<u32> for i32`

1.8.0

`fn shl_assign(&mut self, other: u32)`

The method for the `<<=`

operator

`impl ShlAssign<u64> for i32`

1.8.0

`fn shl_assign(&mut self, other: u64)`

The method for the `<<=`

operator

`impl ShlAssign<usize> for i32`

1.8.0

`fn shl_assign(&mut self, other: usize)`

The method for the `<<=`

operator

`impl ShlAssign<i8> for i32`

1.8.0

`fn shl_assign(&mut self, other: i8)`

The method for the `<<=`

operator

`impl ShlAssign<i16> for i32`

1.8.0

`fn shl_assign(&mut self, other: i16)`

The method for the `<<=`

operator

`impl ShlAssign<i32> for i32`

1.8.0

`fn shl_assign(&mut self, other: i32)`

The method for the `<<=`

operator

`impl ShlAssign<i64> for i32`

1.8.0

`fn shl_assign(&mut self, other: i64)`

The method for the `<<=`

operator

`impl ShlAssign<isize> for i32`

1.8.0

`fn shl_assign(&mut self, other: isize)`

The method for the `<<=`

operator

`impl ShrAssign<u8> for i32`

1.8.0

`fn shr_assign(&mut self, other: u8)`

The method for the `>>=`

operator

`impl ShrAssign<u16> for i32`

1.8.0

`fn shr_assign(&mut self, other: u16)`

The method for the `>>=`

operator

`impl ShrAssign<u32> for i32`

1.8.0

`fn shr_assign(&mut self, other: u32)`

The method for the `>>=`

operator

`impl ShrAssign<u64> for i32`

1.8.0

`fn shr_assign(&mut self, other: u64)`

The method for the `>>=`

operator

`impl ShrAssign<usize> for i32`

1.8.0

`fn shr_assign(&mut self, other: usize)`

The method for the `>>=`

operator

`impl ShrAssign<i8> for i32`

1.8.0

`fn shr_assign(&mut self, other: i8)`

The method for the `>>=`

operator

`impl ShrAssign<i16> for i32`

1.8.0

`fn shr_assign(&mut self, other: i16)`

The method for the `>>=`

operator

`impl ShrAssign<i32> for i32`

1.8.0

`fn shr_assign(&mut self, other: i32)`

The method for the `>>=`

operator

`impl ShrAssign<i64> for i32`

1.8.0

`fn shr_assign(&mut self, other: i64)`

The method for the `>>=`

operator

`impl ShrAssign<isize> for i32`

1.8.0

`fn shr_assign(&mut self, other: isize)`

The method for the `>>=`

operator

`impl PartialEq<i32> for i32`

1.0.0

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

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

This method tests for `!=`

.

`impl Eq for i32`

1.0.0

`impl PartialOrd<i32> for i32`

1.0.0

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

This method tests less than or equal to (for `self`

and `other`

) and is used by the `<=`

operator. Read more

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

This method tests greater than or equal to (for `self`

and `other`

) and is used by the `>=`

operator. Read more

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

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

`impl Ord for i32`

1.0.0

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

This method returns an `Ordering`

between `self`

and `other`

. Read more

`impl Clone for i32`

1.0.0

`fn clone(&self) -> i32`

Returns a deep copy of the value.

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

1.0.0

Performs copy-assignment from `source`

. Read more

`impl Default for i32`

1.0.0

`impl Step for i32`

`fn step(&self, by: &i32) -> Option<i32>`

Steps `self`

if possible.

`fn steps_between(start: &i32, end: &i32, by: &i32) -> Option<usize>`

Returns the number of steps between two step objects. The count is inclusive of `start`

and exclusive of `end`

. Read more

`impl Hash for i32`

1.0.0

`fn hash<H>(&self, state: &mut H) where H: Hasher`

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.