Primitive Type usize []

Operations and constants for pointer-sized unsigned integers (usize`usize` type)

This type was recently added to replace uint`uint`. 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 usize

fn min_value() -> usize

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

fn max_value() -> usize

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

fn from_str_radix(src: &str, radix: u32) -> Result<usize, 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)`Err(ParseIntError)if the string did not represent a valid number. Otherwise,` if the string did not represent a valid number. Otherwise, Ok(n)`Ok(n)where` where n`nis the integer represented by` is the integer represented by src`src`.

fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self`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`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`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`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) -> usize

Shifts the bits to the left by a specified amount, n`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) -> usize

Shifts the bits to the right by a specified amount, n`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) -> usize

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: usize) -> usize

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: usize) -> usize

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

Converts self`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) -> usize

Converts self`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: usize) -> Option<usize>

Checked integer addition. Computes self + other`self + other, returning`, returning None`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: usize) -> Option<usize>

Checked integer subtraction. Computes self - other`self - other, returning`, returning None`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: usize) -> Option<usize>

Checked integer multiplication. Computes self * other`self * other, returning`, returning None`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: usize) -> Option<usize>

Checked integer division. Computes self / other`self / other, returning`, returning None`Noneif` if other == 0`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: usize) -> usize

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

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

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

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

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

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

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

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

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

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

Unstable

Wrapping (modular) division. Computes floor(self / other)`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`MIN / -1on a signed type (where` on a signed type (where MIN`MINis the negative minimal value for the type); this is equivalent to` is the negative minimal value for the type); this is equivalent to -MIN`-MIN, a positive value that is too large to represent in the type. In such a case, this function returns`, a positive value that is too large to represent in the type. In such a case, this function returns MIN`MIN` itself..

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

Unstable

Wrapping (modular) remainder. Computes self % other`self % other`, wrapping around at the boundary of the type.

Such wrap-around never actually occurs mathematically; implementation artifacts make x % y`x % yillegal for` illegal for MIN / -1`MIN / -1on a signed type illegal (where` on a signed type illegal (where MIN`MINis the negative minimal value). In such a case, this function returns` is the negative minimal value). In such a case, this function returns 0`0`.

fn wrapping_neg(self) -> usize

Unstable

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

The only case where such wrapping can occur is when one negates MIN`MINon a signed type (where` on a signed type (where MIN`MINis 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` 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`MIN` itself.

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

Unstable

Panic-free bitwise shift-left; yields self << mask(rhs)`self << mask(rhs), where`, where mask`maskremoves any high-order bits of` removes any high-order bits of rhs`rhs` that would cause the shift to exceed the bitwidth of the type.

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

Unstable

Panic-free bitwise shift-left; yields self >> mask(rhs)`self >> mask(rhs), where`, where mask`maskremoves any high-order bits of` removes any high-order bits of rhs`rhs` that would cause the shift to exceed the bitwidth of the type.

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

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

Examples

fn main() { assert_eq!(2i32.pow(4), 16); }
assert_eq!(2i32.pow(4), 16);

fn is_power_of_two(self) -> bool

Returns true`trueiff` iff self == 2^k`self == 2k` for some k`k`.

fn next_power_of_two(self) -> usize

Returns the smallest power of two greater than or equal to self`self`. Unspecified behavior on overflow.

fn checked_next_power_of_two(self) -> Option<usize>

Returns the smallest power of two greater than or equal to n`n. If the next power of two is greater than the type's maximum value,`. If the next power of two is greater than the type's maximum value, None`Noneis returned, otherwise the power of two is wrapped in` is returned, otherwise the power of two is wrapped in Some`Some`.

Trait Implementations

impl OverflowingOps for usize

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

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

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

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

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

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

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

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

impl Zero for usize

fn zero() -> usize

impl One for usize

fn one() -> usize

impl FromStr for usize

type Err = ParseIntError

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

impl Zeroable for usize

impl Add for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Sub for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Mul for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Div for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Rem for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Not for usize

type Output = usize

fn not(self) -> usize

impl<'a> Not for &'a usize

type Output = usize::Output

fn not(self) -> usize::Output

impl BitAnd for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl BitOr for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl BitXor for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<u8> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<u16> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<u32> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<u64> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<usize> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<i8> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<i16> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<i32> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<i64> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shl<isize> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<u8> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<u16> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<u32> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<u64> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<usize> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<i8> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<i16> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<i32> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<i64> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl Shr<isize> for usize

type Output = usize

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

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

type Output = usize::Output

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

impl PartialEq for usize

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

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

impl Eq for usize

impl PartialOrd for usize

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

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

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

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

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

impl Ord for usize

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

impl Clone for usize

fn clone(&self) -> usize

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

impl Default for usize

fn default() -> usize

impl Step for usize

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

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

impl Hash for usize

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

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

impl Display for usize

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

impl Binary for usize

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

impl Octal for usize

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

impl LowerHex for usize

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

impl UpperHex for usize

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

impl Debug for usize

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