# Primitive Type i8 [−]

The 8-bit signed integer type.

See also the `std::i8` module.

## Methods

### `impl i8`

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

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

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

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

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

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!(u32::from_str_radix("A", 16), Ok(10)); }
`assert_eq!(u32::from_str_radix("A", 16), Ok(10));`

#### `fn count_ones(self) -> u32`

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

# Examples

Basic usage:

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

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

#### `fn count_zeros(self) -> u32`

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

# Examples

Basic usage:

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

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

#### `fn leading_zeros(self) -> u32`

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

# Examples

Basic usage:

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

#### `fn trailing_zeros(self) -> u32`

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

# Examples

Basic usage:

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

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 = 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) -> i8`

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 = 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) -> i8`

Reverses the byte order of the integer.

# Examples

Basic usage:

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: i8) -> i8`

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 = 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: i8) -> i8`

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 = 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) -> i8`

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 = 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) -> i8`

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 = 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: i8) -> Option<i8>`

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

# Examples

Basic usage:

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

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

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

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

# Examples

Basic usage:

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, other: i8) -> Option<i8>`

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

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

# Examples

Basic usage:

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

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

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

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

# Examples

Basic usage:

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

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

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`

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`

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.

# 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`

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`.

# 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`

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`

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.

# Examples

Basic usage:

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

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

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.

# Examples

Basic usage:

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

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

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`

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`

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`

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`

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 Div<i8> for i8`

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

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

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