# Primitive Type i8 [−]

The 8-bit signed integer type.

See also the `std::i8` module.

## Methods

### `impl i8`

#### `const fn min_value() -> i8`1.0.0

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

#### `const fn max_value() -> i8`1.0.0

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

#### `fn from_str_radix(src: &str, radix: u32) -> Result<i8, 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;

#### `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) -> i8`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) -> i8`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) -> i8`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;

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

#### `fn from_be(x: i8) -> i8`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: i8) -> i8`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) -> i8`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) -> i8`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: i8) -> Option<i8>`1.0.0

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

# Examples

Basic usage:

```assert_eq!(7i16.checked_add(32760), Some(32767));

#### `fn checked_sub(self, other: i8) -> Option<i8>`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: i8) -> Option<i8>`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: i8) -> Option<i8>`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: i8) -> Option<i8>`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<i8>`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<i8>`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<i8>`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: i8) -> i8`1.0.0

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

# Examples

Basic usage:

```assert_eq!(100i8.saturating_add(1), 101);

#### `fn saturating_sub(self, other: i8) -> i8`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: i8) -> i8`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: i8) -> i8`1.0.0

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

# Examples

Basic usage:

```assert_eq!(100i8.wrapping_add(27), 127);

#### `fn wrapping_sub(self, rhs: i8) -> i8`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: i8) -> i8`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: i8) -> i8`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: i8) -> i8`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) -> i8`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) -> i8`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) -> i8`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: i8) -> (i8, 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;

#### `fn overflowing_sub(self, rhs: i8) -> (i8, 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: i8) -> (i8, 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: i8) -> (i8, 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: i8) -> (i8, 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) -> (i8, 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) -> (i8, 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) -> (i8, 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) -> i8`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) -> i8`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) -> i8`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 i8`

#### `fn zero() -> i8`

Unstable (`zero_one` #27739)

: unsure of placement, wants to use associated constants

The "zero" (usually, additive identity) for this type.

### `impl One for i8`

#### `fn one() -> i8`

Unstable (`zero_one` #27739)

: unsure of placement, wants to use associated constants

The "one" (usually, multiplicative identity) for this type.

### `impl FromStr for i8`1.0.0

#### `type Err = ParseIntError`

The associated error which can be returned from parsing.

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

Parses a string `s` to return a value of this type. Read more

### `impl TryFrom<i8> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<i16> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<i32> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<i64> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<isize> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<u8> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<u16> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<u32> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<u64> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl TryFrom<usize> for i8`1.0.0

#### `type Err = TryFromIntError`

Unstable (`try_from` #33417)

The type returned in the event of a conversion error.

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

Unstable (`try_from` #33417)

Performs the conversion.

### `impl Add<i8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `+` operator

#### `fn add(self, other: i8) -> i8`

The method for the `+` operator

### `impl<'a> Add<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `+` operator

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

The method for the `+` operator

### `impl<'a> Add<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `+` operator

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

The method for the `+` operator

### `impl<'a, 'b> Add<&'a i8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `+` operator

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

The method for the `+` operator

### `impl Sub<i8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `-` operator

#### `fn sub(self, other: i8) -> i8`

The method for the `-` operator

### `impl<'a> Sub<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `-` operator

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

The method for the `-` operator

### `impl<'a> Sub<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `-` operator

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

The method for the `-` operator

### `impl<'a, 'b> Sub<&'a i8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `-` operator

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

The method for the `-` operator

### `impl Mul<i8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `*` operator

#### `fn mul(self, other: i8) -> i8`

The method for the `*` operator

### `impl<'a> Mul<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `*` operator

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

The method for the `*` operator

### `impl<'a> Mul<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `*` operator

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

The method for the `*` operator

### `impl<'a, 'b> Mul<&'a i8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `*` operator

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

The method for the `*` operator

### `impl Div<i8> for i8`1.0.0

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

#### `type Output = i8`

The resulting type after applying the `/` operator

#### `fn div(self, other: i8) -> i8`

The method for the `/` operator

### `impl<'a> Div<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `/` operator

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

The method for the `/` operator

### `impl<'a> Div<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `/` operator

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

The method for the `/` operator

### `impl<'a, 'b> Div<&'a i8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `/` operator

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

The method for the `/` operator

### `impl Rem<i8> for i8`1.0.0

This operation satisfies `n % d == n - (n / d) * d`. The result has the same sign as the left operand.

#### `type Output = i8`

The resulting type after applying the `%` operator

#### `fn rem(self, other: i8) -> i8`

The method for the `%` operator

### `impl<'a> Rem<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `%` operator

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

The method for the `%` operator

### `impl<'a> Rem<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `%` operator

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

The method for the `%` operator

### `impl<'a, 'b> Rem<&'a i8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `%` operator

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

The method for the `%` operator

### `impl Neg for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `-` operator

#### `fn neg(self) -> i8`

The method for the unary `-` operator

### `impl<'a> Neg for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `-` operator

#### `fn neg(self) -> i8::Output`

The method for the unary `-` operator

### `impl Not for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `!` operator

#### `fn not(self) -> i8`

The method for the unary `!` operator

### `impl<'a> Not for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `!` operator

#### `fn not(self) -> i8::Output`

The method for the unary `!` operator

### `impl BitAnd<i8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `&` operator

#### `fn bitand(self, rhs: i8) -> i8`

The method for the `&` operator

### `impl<'a> BitAnd<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `&` operator

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

The method for the `&` operator

### `impl<'a> BitAnd<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `&` operator

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

The method for the `&` operator

### `impl<'a, 'b> BitAnd<&'a i8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `&` operator

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

The method for the `&` operator

### `impl BitOr<i8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `|` operator

#### `fn bitor(self, rhs: i8) -> i8`

The method for the `|` operator

### `impl<'a> BitOr<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `|` operator

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

The method for the `|` operator

### `impl<'a> BitOr<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `|` operator

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

The method for the `|` operator

### `impl<'a, 'b> BitOr<&'a i8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `|` operator

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

The method for the `|` operator

### `impl BitXor<i8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `^` operator

#### `fn bitxor(self, other: i8) -> i8`

The method for the `^` operator

### `impl<'a> BitXor<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `^` operator

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

The method for the `^` operator

### `impl<'a> BitXor<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `^` operator

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

The method for the `^` operator

### `impl<'a, 'b> BitXor<&'a i8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `^` operator

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

The method for the `^` operator

### `impl Shl<u8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<u8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a u8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a, 'b> Shl<&'a u8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<u16> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<u16> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a u16> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a, 'b> Shl<&'a u16> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<u32> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<u32> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a u32> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a, 'b> Shl<&'a u32> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<u64> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<u64> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a u64> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a, 'b> Shl<&'a u64> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<usize> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<usize> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a usize> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<i8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<i16> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<i16> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a i16> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a, 'b> Shl<&'a i16> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<i32> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<i64> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<i64> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a i64> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a, 'b> Shl<&'a i64> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shl<isize> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<isize> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl<'a> Shl<&'a isize> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `<<` operator

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

The method for the `<<` operator

### `impl Shr<u8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<u8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a u8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a, 'b> Shr<&'a u8> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<u16> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<u16> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a u16> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a, 'b> Shr<&'a u16> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<u32> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<u32> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a u32> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a, 'b> Shr<&'a u32> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<u64> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<u64> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a u64> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a, 'b> Shr<&'a u64> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<usize> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<usize> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a usize> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<i8> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<i8> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a i8> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<i16> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<i16> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a i16> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a, 'b> Shr<&'a i16> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<i32> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<i64> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<i64> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a i64> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a, 'b> Shr<&'a i64> for &'b i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl Shr<isize> for i8`1.0.0

#### `type Output = i8`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<isize> for &'a i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl<'a> Shr<&'a isize> for i8`1.0.0

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

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

#### `type Output = i8::Output`

The resulting type after applying the `>>` operator

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

The method for the `>>` operator

### `impl AddAssign<i8> for i8`1.8.0

#### `fn add_assign(&mut self, other: i8)`

The method for the `+=` operator

### `impl SubAssign<i8> for i8`1.8.0

#### `fn sub_assign(&mut self, other: i8)`

The method for the `-=` operator

### `impl MulAssign<i8> for i8`1.8.0

#### `fn mul_assign(&mut self, other: i8)`

The method for the `*=` operator

### `impl DivAssign<i8> for i8`1.8.0

#### `fn div_assign(&mut self, other: i8)`

The method for the `/=` operator

### `impl RemAssign<i8> for i8`1.8.0

#### `fn rem_assign(&mut self, other: i8)`

The method for the `%=` operator

### `impl BitAndAssign<i8> for i8`1.8.0

#### `fn bitand_assign(&mut self, other: i8)`

The method for the `&` operator

### `impl BitOrAssign<i8> for i8`1.8.0

#### `fn bitor_assign(&mut self, other: i8)`

The method for the `|=` operator

### `impl BitXorAssign<i8> for i8`1.8.0

#### `fn bitxor_assign(&mut self, other: i8)`

The method for the `^=` operator

### `impl ShlAssign<u8> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<u16> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<u32> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<u64> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<usize> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<i8> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<i16> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<i32> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<i64> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShlAssign<isize> for i8`1.8.0

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

The method for the `<<=` operator

### `impl ShrAssign<u8> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<u16> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<u32> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<u64> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<usize> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<i8> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<i16> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<i32> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<i64> for i8`1.8.0

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

The method for the `>>=` operator

### `impl ShrAssign<isize> for i8`1.8.0

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

The method for the `>>=` operator

### `impl PartialEq<i8> for i8`1.0.0

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

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

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

This method tests for `!=`.

### `impl PartialOrd<i8> for i8`1.0.0

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

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

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `fn le(&self, other: &i8) -> 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: &i8) -> 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: &i8) -> bool`

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

### `impl Ord for i8`1.0.0

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

This method returns an `Ordering` between `self` and `other`. Read more

### `impl Clone for i8`1.0.0

#### `fn clone(&self) -> i8`

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 i8`1.0.0

#### `fn default() -> i8`

Returns the "default value" for a type. Read more

### `impl Step for i8`

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

Unstable (`step_trait` #27741)

: likely to be replaced by finer-grained traits

Steps `self` if possible.

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

Unstable (`step_trait` #27741)

: likely to be replaced by finer-grained traits

Returns the number of steps between two step objects. The count is inclusive of `start` and exclusive of `end`. Read more

### `impl Hash for i8`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: &[i8], state: &mut H) where H: Hasher`

Feeds a slice of this type into the state provided.

### `impl Binary for i8`1.0.0

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

Formats the value using the given formatter.

### `impl Octal for i8`1.0.0

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

Formats the value using the given formatter.

### `impl LowerHex for i8`1.0.0

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

Formats the value using the given formatter.

### `impl UpperHex for i8`1.0.0

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

Formats the value using the given formatter.

### `impl Debug for i8`1.0.0

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

Formats the value using the given formatter.

### `impl Display for i8`1.0.0

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

Formats the value using the given formatter.