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.

Trait Implementations

impl Int for isize

fn zero() -> isize

fn one() -> isize

fn min_value() -> isize

fn max_value() -> isize

fn count_ones(self) -> usize

fn leading_zeros(self) -> usize

fn trailing_zeros(self) -> usize

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

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

fn swap_bytes(self) -> isize

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

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

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

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

fn count_zeros(self) -> usize

fn from_be(isize) -> isize

fn from_le(isize) -> isize

fn to_be(self) -> isize

fn to_le(self) -> isize

fn saturating_add(self, isize) -> isize

fn saturating_sub(self, isize) -> isize

fn pow(self, usize) -> isize

impl SignedInt for isize

fn abs(self) -> isize

fn signum(self) -> isize

fn is_positive(self) -> bool

fn is_negative(self) -> bool

impl ToPrimitive for isize

fn to_int(&self) -> Option<isize>

fn to_i8(&self) -> Option<i8>

fn to_i16(&self) -> Option<i16>

fn to_i32(&self) -> Option<i32>

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

fn to_uint(&self) -> Option<usize>

fn to_u8(&self) -> Option<u8>

fn to_u16(&self) -> Option<u16>

fn to_u32(&self) -> Option<u32>

fn to_u64(&self) -> Option<u64>

fn to_f32(&self) -> Option<f32>

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

fn to_int(&self) -> Option<isize>

fn to_i8(&self) -> Option<i8>

fn to_i16(&self) -> Option<i16>

fn to_i32(&self) -> Option<i32>

fn to_uint(&self) -> Option<usize>

fn to_u8(&self) -> Option<u8>

fn to_u16(&self) -> Option<u16>

fn to_u32(&self) -> Option<u32>

fn to_f32(&self) -> Option<f32>

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

impl FromPrimitive for isize

fn from_int(n: isize) -> Option<isize>

fn from_i8(n: i8) -> Option<isize>

fn from_i16(n: i16) -> Option<isize>

fn from_i32(n: i32) -> Option<isize>

fn from_i64(n: i64) -> Option<isize>

fn from_uint(n: usize) -> Option<isize>

fn from_u8(n: u8) -> Option<isize>

fn from_u16(n: u16) -> Option<isize>

fn from_u32(n: u32) -> Option<isize>

fn from_u64(n: u64) -> Option<isize>

fn from_f32(n: f32) -> Option<isize>

fn from_f64(n: f64) -> Option<isize>

fn from_int(isize) -> Option<isize>

fn from_i8(i8) -> Option<isize>

fn from_i16(i16) -> Option<isize>

fn from_i32(i32) -> Option<isize>

fn from_uint(usize) -> Option<isize>

fn from_u8(u8) -> Option<isize>

fn from_u16(u16) -> Option<isize>

fn from_u32(u32) -> Option<isize>

fn from_f32(f32) -> Option<isize>

fn from_f64(f64) -> Option<isize>

impl NumCast for isize

fn from<N>(n: N) -> Option<isize> where N: ToPrimitive

impl FromStr for isize

type Err = ParseIntError

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

impl FromStrRadix for isize

type Err = ParseIntError

fn from_str_radix(src: &str, radix: u32) -> 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 as Add<isize>>::Output

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

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

type Output = <isize as Add<isize>>::Output

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

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

type Output = <isize as Add<isize>>::Output

fn add(self, other: &'a isize) -> <isize as Add<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 as Sub<isize>>::Output

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

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

type Output = <isize as Sub<isize>>::Output

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

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

type Output = <isize as Sub<isize>>::Output

fn sub(self, other: &'a isize) -> <isize as Sub<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 as Mul<isize>>::Output

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

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

type Output = <isize as Mul<isize>>::Output

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

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

type Output = <isize as Mul<isize>>::Output

fn mul(self, other: &'a isize) -> <isize as Mul<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 as Div<isize>>::Output

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

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

type Output = <isize as Div<isize>>::Output

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

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

type Output = <isize as Div<isize>>::Output

fn div(self, other: &'a isize) -> <isize as Div<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 as Rem<isize>>::Output

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

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

type Output = <isize as Rem<isize>>::Output

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

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

type Output = <isize as Rem<isize>>::Output

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

impl Neg for isize

type Output = isize

fn neg(self) -> isize

impl<'a> Neg for &'a isize

type Output = <isize as Neg>::Output

fn neg(self) -> <isize as Neg>::Output

impl Not for isize

type Output = isize

fn not(self) -> isize

impl<'a> Not for &'a isize

type Output = <isize as Not>::Output

fn not(self) -> <isize as Not>::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 as BitAnd<isize>>::Output

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

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

type Output = <isize as BitAnd<isize>>::Output

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

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

type Output = <isize as BitAnd<isize>>::Output

fn bitand(self, other: &'a isize) -> <isize as BitAnd<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 as BitOr<isize>>::Output

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

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

type Output = <isize as BitOr<isize>>::Output

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

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

type Output = <isize as BitOr<isize>>::Output

fn bitor(self, other: &'a isize) -> <isize as BitOr<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 as BitXor<isize>>::Output

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

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

type Output = <isize as BitXor<isize>>::Output

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

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

type Output = <isize as BitXor<isize>>::Output

fn bitxor(self, other: &'a isize) -> <isize as BitXor<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 as Shl<u8>>::Output

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

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

type Output = <isize as Shl<u8>>::Output

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

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

type Output = <isize as Shl<u8>>::Output

fn shl(self, other: &'a u8) -> <isize as Shl<u8>>::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 as Shl<u16>>::Output

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

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

type Output = <isize as Shl<u16>>::Output

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

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

type Output = <isize as Shl<u16>>::Output

fn shl(self, other: &'a u16) -> <isize as Shl<u16>>::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 as Shl<u32>>::Output

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

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

type Output = <isize as Shl<u32>>::Output

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

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

type Output = <isize as Shl<u32>>::Output

fn shl(self, other: &'a u32) -> <isize as Shl<u32>>::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 as Shl<u64>>::Output

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

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

type Output = <isize as Shl<u64>>::Output

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

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

type Output = <isize as Shl<u64>>::Output

fn shl(self, other: &'a u64) -> <isize as Shl<u64>>::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 as Shl<usize>>::Output

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

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

type Output = <isize as Shl<usize>>::Output

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

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

type Output = <isize as Shl<usize>>::Output

fn shl(self, other: &'a usize) -> <isize as Shl<usize>>::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 as Shl<i8>>::Output

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

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

type Output = <isize as Shl<i8>>::Output

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

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

type Output = <isize as Shl<i8>>::Output

fn shl(self, other: &'a i8) -> <isize as Shl<i8>>::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 as Shl<i16>>::Output

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

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

type Output = <isize as Shl<i16>>::Output

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

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

type Output = <isize as Shl<i16>>::Output

fn shl(self, other: &'a i16) -> <isize as Shl<i16>>::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 as Shl<i32>>::Output

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

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

type Output = <isize as Shl<i32>>::Output

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

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

type Output = <isize as Shl<i32>>::Output

fn shl(self, other: &'a i32) -> <isize as Shl<i32>>::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 as Shl<i64>>::Output

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

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

type Output = <isize as Shl<i64>>::Output

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

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

type Output = <isize as Shl<i64>>::Output

fn shl(self, other: &'a i64) -> <isize as Shl<i64>>::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 as Shl<isize>>::Output

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

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

type Output = <isize as Shl<isize>>::Output

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

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

type Output = <isize as Shl<isize>>::Output

fn shl(self, other: &'a isize) -> <isize as Shl<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 as Shr<u8>>::Output

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

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

type Output = <isize as Shr<u8>>::Output

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

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

type Output = <isize as Shr<u8>>::Output

fn shr(self, other: &'a u8) -> <isize as Shr<u8>>::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 as Shr<u16>>::Output

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

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

type Output = <isize as Shr<u16>>::Output

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

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

type Output = <isize as Shr<u16>>::Output

fn shr(self, other: &'a u16) -> <isize as Shr<u16>>::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 as Shr<u32>>::Output

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

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

type Output = <isize as Shr<u32>>::Output

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

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

type Output = <isize as Shr<u32>>::Output

fn shr(self, other: &'a u32) -> <isize as Shr<u32>>::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 as Shr<u64>>::Output

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

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

type Output = <isize as Shr<u64>>::Output

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

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

type Output = <isize as Shr<u64>>::Output

fn shr(self, other: &'a u64) -> <isize as Shr<u64>>::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 as Shr<usize>>::Output

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

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

type Output = <isize as Shr<usize>>::Output

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

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

type Output = <isize as Shr<usize>>::Output

fn shr(self, other: &'a usize) -> <isize as Shr<usize>>::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 as Shr<i8>>::Output

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

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

type Output = <isize as Shr<i8>>::Output

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

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

type Output = <isize as Shr<i8>>::Output

fn shr(self, other: &'a i8) -> <isize as Shr<i8>>::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 as Shr<i16>>::Output

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

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

type Output = <isize as Shr<i16>>::Output

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

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

type Output = <isize as Shr<i16>>::Output

fn shr(self, other: &'a i16) -> <isize as Shr<i16>>::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 as Shr<i32>>::Output

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

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

type Output = <isize as Shr<i32>>::Output

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

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

type Output = <isize as Shr<i32>>::Output

fn shr(self, other: &'a i32) -> <isize as Shr<i32>>::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 as Shr<i64>>::Output

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

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

type Output = <isize as Shr<i64>>::Output

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

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

type Output = <isize as Shr<i64>>::Output

fn shr(self, other: &'a i64) -> <isize as Shr<i64>>::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 as Shr<isize>>::Output

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

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

type Output = <isize as Shr<isize>>::Output

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

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

type Output = <isize as Shr<isize>>::Output

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

impl PartialEq<isize> for isize

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

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

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

impl Eq for isize

fn assert_receiver_is_total_eq(&self)

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

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

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

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

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

impl Ord for isize

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

impl Clone for isize

fn clone(&self) -> isize

Return a deep copy of the value.

fn clone_from(&mut self, &isize)

impl Default for isize

fn default() -> isize

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

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

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