Primitive Type isize []

Operations and constants for pointer-sized signed integers (isize type)

This type was recently added to replace int. The rollout of the new type will gradually take place over the alpha cycle along with the development of clearer conventions around integer types.

Methods

impl isize

fn min_value() -> isize

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

fn max_value() -> isize

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

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

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

Leading and trailing whitespace represent an error.

Arguments

  • src - A string slice
  • radix - The base to use. Must lie in the range [2 .. 36]

Return value

Err(ParseIntError) if the string did not represent a valid number. Otherwise, Ok(n) where n is the integer represented by src.

fn count_ones(self) -> u32

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

Examples

fn main() { let n = 0b01001100u8; assert_eq!(n.count_ones(), 3); }
let n = 0b01001100u8;

assert_eq!(n.count_ones(), 3);

fn count_zeros(self) -> u32

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

Examples

fn main() { let n = 0b01001100u8; assert_eq!(n.count_zeros(), 5); }
let n = 0b01001100u8;

assert_eq!(n.count_zeros(), 5);

fn leading_zeros(self) -> u32

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

Examples

fn main() { let n = 0b0101000u16; assert_eq!(n.leading_zeros(), 10); }
let n = 0b0101000u16;

assert_eq!(n.leading_zeros(), 10);

fn trailing_zeros(self) -> u32

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

Examples

fn main() { let n = 0b0101000u16; assert_eq!(n.trailing_zeros(), 3); }
let n = 0b0101000u16;

assert_eq!(n.trailing_zeros(), 3);

fn rotate_left(self, n: u32) -> isize

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Examples

fn main() { let n = 0x0123456789ABCDEFu64; let m = 0x3456789ABCDEF012u64; assert_eq!(n.rotate_left(12), m); }
let n = 0x0123456789ABCDEFu64;
let m = 0x3456789ABCDEF012u64;

assert_eq!(n.rotate_left(12), m);

fn rotate_right(self, n: u32) -> isize

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Examples

fn main() { let n = 0x0123456789ABCDEFu64; let m = 0xDEF0123456789ABCu64; assert_eq!(n.rotate_right(12), m); }
let n = 0x0123456789ABCDEFu64;
let m = 0xDEF0123456789ABCu64;

assert_eq!(n.rotate_right(12), m);

fn swap_bytes(self) -> isize

Reverses the byte order of the integer.

Examples

fn main() { let n = 0x0123456789ABCDEFu64; let m = 0xEFCDAB8967452301u64; assert_eq!(n.swap_bytes(), m); }
let n = 0x0123456789ABCDEFu64;
let m = 0xEFCDAB8967452301u64;

assert_eq!(n.swap_bytes(), m);

fn from_be(x: isize) -> isize

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

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

if cfg!(target_endian = "big") {
    assert_eq!(u64::from_be(n), n)
} else {
    assert_eq!(u64::from_be(n), n.swap_bytes())
}

fn from_le(x: isize) -> isize

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

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

if cfg!(target_endian = "little") {
    assert_eq!(u64::from_le(n), n)
} else {
    assert_eq!(u64::from_le(n), n.swap_bytes())
}

fn to_be(self) -> isize

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

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

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

fn to_le(self) -> isize

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

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

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: isize) -> Option<isize>

Checked integer addition. Computes self + other, returning None if overflow occurred.

Examples

fn main() { assert_eq!(5u16.checked_add(65530), Some(65535)); assert_eq!(6u16.checked_add(65530), None); }
assert_eq!(5u16.checked_add(65530), Some(65535));
assert_eq!(6u16.checked_add(65530), None);

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

Checked integer subtraction. Computes self - other, returning None if underflow occurred.

Examples

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: isize) -> Option<isize>

Checked integer multiplication. Computes self * other, returning None if underflow or overflow occurred.

Examples

fn main() { assert_eq!(5u8.checked_mul(51), Some(255)); assert_eq!(5u8.checked_mul(52), None); }
assert_eq!(5u8.checked_mul(51), Some(255));
assert_eq!(5u8.checked_mul(52), None);

fn checked_div(self, v: isize) -> Option<isize>

Checked integer division. Computes self / other, returning None if other == 0 or the operation results in underflow or overflow.

Examples

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 saturating_add(self, other: isize) -> isize

Saturating integer addition. Computes self + other, saturating at the numeric bounds instead of overflowing.

fn saturating_sub(self, other: isize) -> isize

Saturating integer subtraction. Computes self - other, saturating at the numeric bounds instead of overflowing.

fn wrapping_add(self, rhs: isize) -> isize

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

fn wrapping_sub(self, rhs: isize) -> isize

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

fn wrapping_mul(self, rhs: isize) -> isize

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

fn wrapping_div(self, rhs: isize) -> isize

Unstable

Wrapping (modular) division. Computes floor(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..

fn wrapping_rem(self, rhs: isize) -> isize

Unstable

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 illegal for MIN / -1 on a signed type illegal (where MIN is the negative minimal value). In such a case, this function returns 0.

fn wrapping_neg(self) -> isize

Unstable

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.

fn wrapping_shl(self, rhs: u32) -> isize

Unstable

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.

fn wrapping_shr(self, rhs: u32) -> isize

Unstable

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.

fn pow(self, exp: u32) -> isize

Raises self to the power of exp, using exponentiation by squaring.

Examples

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) -> isize

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.

fn signum(self) -> isize

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

fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

Trait Implementations

impl OverflowingOps for isize

fn overflowing_add(self, rhs: isize) -> (isize, bool)

fn overflowing_sub(self, rhs: isize) -> (isize, bool)

fn overflowing_mul(self, rhs: isize) -> (isize, bool)

fn overflowing_div(self, rhs: isize) -> (isize, bool)

fn overflowing_rem(self, rhs: isize) -> (isize, bool)

fn overflowing_neg(self) -> (isize, bool)

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

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

impl Zero for isize

fn zero() -> isize

impl One for isize

fn one() -> isize

impl FromStr for isize

type Err = ParseIntError

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

impl Zeroable for isize

impl Add<isize> for isize

type Output = isize

fn add(self, other: isize) -> isize

impl<'a> Add<isize> for &'a isize

type Output = isize::Output

fn add(self, other: isize) -> isize::Output

impl<'a> Add<&'a isize> for isize

type Output = isize::Output

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

impl<'a, 'b> Add<&'a isize> for &'b isize

type Output = isize::Output

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

impl Sub<isize> for isize

type Output = isize

fn sub(self, other: isize) -> isize

impl<'a> Sub<isize> for &'a isize

type Output = isize::Output

fn sub(self, other: isize) -> isize::Output

impl<'a> Sub<&'a isize> for isize

type Output = isize::Output

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

impl<'a, 'b> Sub<&'a isize> for &'b isize

type Output = isize::Output

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

impl Mul<isize> for isize

type Output = isize

fn mul(self, other: isize) -> isize

impl<'a> Mul<isize> for &'a isize

type Output = isize::Output

fn mul(self, other: isize) -> isize::Output

impl<'a> Mul<&'a isize> for isize

type Output = isize::Output

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

impl<'a, 'b> Mul<&'a isize> for &'b isize

type Output = isize::Output

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

impl Div<isize> for isize

type Output = isize

fn div(self, other: isize) -> isize

impl<'a> Div<isize> for &'a isize

type Output = isize::Output

fn div(self, other: isize) -> isize::Output

impl<'a> Div<&'a isize> for isize

type Output = isize::Output

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

impl<'a, 'b> Div<&'a isize> for &'b isize

type Output = isize::Output

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

impl Rem<isize> for isize

type Output = isize

fn rem(self, other: isize) -> isize

impl<'a> Rem<isize> for &'a isize

type Output = isize::Output

fn rem(self, other: isize) -> isize::Output

impl<'a> Rem<&'a isize> for isize

type Output = isize::Output

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

impl<'a, 'b> Rem<&'a isize> for &'b isize

type Output = isize::Output

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

impl Neg for isize

type Output = isize

fn neg(self) -> isize

impl<'a> Neg for &'a isize

type Output = isize::Output

fn neg(self) -> isize::Output

impl Not for isize

type Output = isize

fn not(self) -> isize

impl<'a> Not for &'a isize

type Output = isize::Output

fn not(self) -> isize::Output

impl BitAnd<isize> for isize

type Output = isize

fn bitand(self, rhs: isize) -> isize

impl<'a> BitAnd<isize> for &'a isize

type Output = isize::Output

fn bitand(self, other: isize) -> isize::Output

impl<'a> BitAnd<&'a isize> for isize

type Output = isize::Output

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

impl<'a, 'b> BitAnd<&'a isize> for &'b isize

type Output = isize::Output

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

impl BitOr<isize> for isize

type Output = isize

fn bitor(self, rhs: isize) -> isize

impl<'a> BitOr<isize> for &'a isize

type Output = isize::Output

fn bitor(self, other: isize) -> isize::Output

impl<'a> BitOr<&'a isize> for isize

type Output = isize::Output

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

impl<'a, 'b> BitOr<&'a isize> for &'b isize

type Output = isize::Output

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

impl BitXor<isize> for isize

type Output = isize

fn bitxor(self, other: isize) -> isize

impl<'a> BitXor<isize> for &'a isize

type Output = isize::Output

fn bitxor(self, other: isize) -> isize::Output

impl<'a> BitXor<&'a isize> for isize

type Output = isize::Output

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

impl<'a, 'b> BitXor<&'a isize> for &'b isize

type Output = isize::Output

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

impl Shl<u8> for isize

type Output = isize

fn shl(self, other: u8) -> isize

impl<'a> Shl<u8> for &'a isize

type Output = isize::Output

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

impl<'a> Shl<&'a u8> for isize

type Output = isize::Output

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

impl<'a, 'b> Shl<&'a u8> for &'b isize

type Output = isize::Output

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

impl Shl<u16> for isize

type Output = isize

fn shl(self, other: u16) -> isize

impl<'a> Shl<u16> for &'a isize

type Output = isize::Output

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

impl<'a> Shl<&'a u16> for isize

type Output = isize::Output

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

impl<'a, 'b> Shl<&'a u16> for &'b isize

type Output = isize::Output

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

impl Shl<u32> for isize

type Output = isize

fn shl(self, other: u32) -> isize

impl<'a> Shl<u32> for &'a isize

type Output = isize::Output

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

impl<'a> Shl<&'a u32> for isize

type Output = isize::Output

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

impl<'a, 'b> Shl<&'a u32> for &'b isize

type Output = isize::Output

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

impl Shl<u64> for isize

type Output = isize

fn shl(self, other: u64) -> isize

impl<'a> Shl<u64> for &'a isize

type Output = isize::Output

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

impl<'a> Shl<&'a u64> for isize

type Output = isize::Output

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

impl<'a, 'b> Shl<&'a u64> for &'b isize

type Output = isize::Output

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

impl Shl<usize> for isize

type Output = isize

fn shl(self, other: usize) -> isize

impl<'a> Shl<usize> for &'a isize

type Output = isize::Output

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

impl<'a> Shl<&'a usize> for isize

type Output = isize::Output

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

impl<'a, 'b> Shl<&'a usize> for &'b isize

type Output = isize::Output

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

impl Shl<i8> for isize

type Output = isize

fn shl(self, other: i8) -> isize

impl<'a> Shl<i8> for &'a isize

type Output = isize::Output

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

impl<'a> Shl<&'a i8> for isize

type Output = isize::Output

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

impl<'a, 'b> Shl<&'a i8> for &'b isize

type Output = isize::Output

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

impl Shl<i16> for isize

type Output = isize

fn shl(self, other: i16) -> isize

impl<'a> Shl<i16> for &'a isize

type Output = isize::Output

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

impl<'a> Shl<&'a i16> for isize

type Output = isize::Output

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

impl<'a, 'b> Shl<&'a i16> for &'b isize

type Output = isize::Output

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

impl Shl<i32> for isize

type Output = isize

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

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

type Output = isize::Output

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

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

type Output = isize::Output

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

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

type Output = isize::Output

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

impl Shl<i64> for isize

type Output = isize

fn shl(self, other: i64) -> isize

impl<'a> Shl<i64> for &'a isize

type Output = isize::Output

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

impl<'a> Shl<&'a i64> for isize

type Output = isize::Output

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

impl<'a, 'b> Shl<&'a i64> for &'b isize

type Output = isize::Output

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

impl Shl<isize> for isize

type Output = isize

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

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

type Output = isize::Output

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

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

type Output = isize::Output

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

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

type Output = isize::Output

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

impl Shr<u8> for isize

type Output = isize

fn shr(self, other: u8) -> isize

impl<'a> Shr<u8> for &'a isize

type Output = isize::Output

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

impl<'a> Shr<&'a u8> for isize

type Output = isize::Output

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

impl<'a, 'b> Shr<&'a u8> for &'b isize

type Output = isize::Output

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

impl Shr<u16> for isize

type Output = isize

fn shr(self, other: u16) -> isize

impl<'a> Shr<u16> for &'a isize

type Output = isize::Output

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

impl<'a> Shr<&'a u16> for isize

type Output = isize::Output

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

impl<'a, 'b> Shr<&'a u16> for &'b isize

type Output = isize::Output

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

impl Shr<u32> for isize

type Output = isize

fn shr(self, other: u32) -> isize

impl<'a> Shr<u32> for &'a isize

type Output = isize::Output

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

impl<'a> Shr<&'a u32> for isize

type Output = isize::Output

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

impl<'a, 'b> Shr<&'a u32> for &'b isize

type Output = isize::Output

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

impl Shr<u64> for isize

type Output = isize

fn shr(self, other: u64) -> isize

impl<'a> Shr<u64> for &'a isize

type Output = isize::Output

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

impl<'a> Shr<&'a u64> for isize

type Output = isize::Output

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

impl<'a, 'b> Shr<&'a u64> for &'b isize

type Output = isize::Output

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

impl Shr<usize> for isize

type Output = isize

fn shr(self, other: usize) -> isize

impl<'a> Shr<usize> for &'a isize

type Output = isize::Output

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

impl<'a> Shr<&'a usize> for isize

type Output = isize::Output

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

impl<'a, 'b> Shr<&'a usize> for &'b isize

type Output = isize::Output

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

impl Shr<i8> for isize

type Output = isize

fn shr(self, other: i8) -> isize

impl<'a> Shr<i8> for &'a isize

type Output = isize::Output

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

impl<'a> Shr<&'a i8> for isize

type Output = isize::Output

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

impl<'a, 'b> Shr<&'a i8> for &'b isize

type Output = isize::Output

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

impl Shr<i16> for isize

type Output = isize

fn shr(self, other: i16) -> isize

impl<'a> Shr<i16> for &'a isize

type Output = isize::Output

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

impl<'a> Shr<&'a i16> for isize

type Output = isize::Output

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

impl<'a, 'b> Shr<&'a i16> for &'b isize

type Output = isize::Output

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

impl Shr<i32> for isize

type Output = isize

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

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

type Output = isize::Output

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

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

type Output = isize::Output

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

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

type Output = isize::Output

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

impl Shr<i64> for isize

type Output = isize

fn shr(self, other: i64) -> isize

impl<'a> Shr<i64> for &'a isize

type Output = isize::Output

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

impl<'a> Shr<&'a i64> for isize

type Output = isize::Output

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

impl<'a, 'b> Shr<&'a i64> for &'b isize

type Output = isize::Output

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

impl Shr<isize> for isize

type Output = isize

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

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

type Output = isize::Output

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

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

type Output = isize::Output

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

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

type Output = isize::Output

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

impl PartialEq<isize> for isize

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

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

impl Eq for isize

impl PartialOrd<isize> for isize

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

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

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

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

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

impl Ord for isize

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

impl Clone for isize

fn clone(&self) -> isize

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

impl Default for isize

fn default() -> isize

impl Step for isize

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

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

impl Hash for isize

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

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

impl Display for isize

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

impl Binary for isize

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

impl Octal for isize

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

impl LowerHex for isize

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

impl UpperHex for isize

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

impl Debug for isize

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

impl SampleRange for isize

fn construct_range(low: isize, high: isize) -> Range<isize>

fn sample_range<R>(r: &Range<isize>, rng: &mut R) -> isize where R: Rng

impl Rand for isize

fn rand<R>(rng: &mut R) -> isize where R: Rng