pub struct NonZeroI8(/* private fields */);
Expand description
An integer that is known not to equal zero.
This enables some memory layout optimization.
For example, Option<NonZeroI8>
is the same size as i8
:
use std::mem::size_of;
assert_eq!(size_of::<Option<core::num::NonZeroI8>>(), size_of::<i8>());
RunLayout
NonZeroI8
is guaranteed to have the same layout and bit validity as i8
with the exception that 0
is not a valid instance.
Option<NonZeroI8>
is guaranteed to be compatible with i8
,
including in FFI.
Thanks to the null pointer optimization,
NonZeroI8
and Option<NonZeroI8>
are guaranteed to have the same size and alignment:
use std::num::NonZeroI8;
assert_eq!(size_of::<NonZeroI8>(), size_of::<Option<NonZeroI8>>());
assert_eq!(align_of::<NonZeroI8>(), align_of::<Option<NonZeroI8>>());
RunImplementations§
source§impl NonZeroI8
impl NonZeroI8
const: 1.34.0 · sourcepub const unsafe fn new_unchecked(n: i8) -> NonZeroI8
pub const unsafe fn new_unchecked(n: i8) -> NonZeroI8
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
Safety
The value must not be zero.
source§impl NonZeroI8
impl NonZeroI8
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
Returns the number of leading zeros in the binary representation of self
.
On many architectures, this function can perform better than leading_zeros()
on the underlying integer type, as special handling of zero can be avoided.
Examples
Basic usage:
let n = std::num::NonZeroI8::new(-1i8).unwrap();
assert_eq!(n.leading_zeros(), 0);
Run1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
Returns the number of trailing zeros in the binary representation
of self
.
On many architectures, this function can perform better than trailing_zeros()
on the underlying integer type, as special handling of zero can be avoided.
Examples
Basic usage:
let n = std::num::NonZeroI8::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
Runsource§impl NonZeroI8
impl NonZeroI8
1.64.0 (const: 1.64.0) · sourcepub const fn checked_abs(self) -> Option<NonZeroI8>
pub const fn checked_abs(self) -> Option<NonZeroI8>
Checked absolute value.
Checks for overflow and returns None
if
self == NonZeroI8::MIN
.
The result cannot be zero.
Example
let pos = NonZeroI8::new(1)?;
let neg = NonZeroI8::new(-1)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn overflowing_abs(self) -> (NonZeroI8, bool)
pub const fn overflowing_abs(self) -> (NonZeroI8, bool)
Computes the absolute value of self,
with overflow information, see
i8::overflowing_abs
.
Example
let pos = NonZeroI8::new(1)?;
let neg = NonZeroI8::new(-1)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_abs(self) -> NonZeroI8
pub const fn saturating_abs(self) -> NonZeroI8
Saturating absolute value, see
i8::saturating_abs
.
Example
let pos = NonZeroI8::new(1)?;
let neg = NonZeroI8::new(-1)?;
let min = NonZeroI8::new(i8::MIN)?;
let min_plus = NonZeroI8::new(i8::MIN + 1)?;
let max = NonZeroI8::new(i8::MAX)?;
assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn wrapping_abs(self) -> NonZeroI8
pub const fn wrapping_abs(self) -> NonZeroI8
Wrapping absolute value, see
i8::wrapping_abs
.
Example
let pos = NonZeroI8::new(1)?;
let neg = NonZeroI8::new(-1)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
assert_eq!(max, (-max).wrapping_abs());
Run1.64.0 (const: 1.64.0) · sourcepub const fn unsigned_abs(self) -> NonZeroU8
pub const fn unsigned_abs(self) -> NonZeroU8
Computes the absolute value of self without any wrapping or panicking.
Example
let u_pos = NonZeroU8::new(1)?;
let i_pos = NonZeroI8::new(1)?;
let i_neg = NonZeroI8::new(-1)?;
let i_min = NonZeroI8::new(i8::MIN)?;
let u_max = NonZeroU8::new(u8::MAX / 2 + 1)?;
assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());
Run1.71.0 (const: 1.71.0) · sourcepub const fn is_positive(self) -> bool
pub const fn is_positive(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn is_negative(self) -> bool
pub const fn is_negative(self) -> bool
1.71.0 (const: 1.71.0) · sourcepub const fn checked_neg(self) -> Option<NonZeroI8>
pub const fn checked_neg(self) -> Option<NonZeroI8>
1.71.0 (const: 1.71.0) · sourcepub const fn overflowing_neg(self) -> (NonZeroI8, bool)
pub const fn overflowing_neg(self) -> (NonZeroI8, bool)
Negates self, overflowing if this is equal to the minimum value.
See i8::overflowing_neg
for documentation on overflow behaviour.
Example
let pos_five = NonZeroI8::new(5)?;
let neg_five = NonZeroI8::new(-5)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
Run1.71.0 (const: 1.71.0) · sourcepub const fn saturating_neg(self) -> NonZeroI8
pub const fn saturating_neg(self) -> NonZeroI8
Saturating negation. Computes -self
,
returning NonZeroI8::MAX
if self == NonZeroI8::MIN
instead of overflowing.
Example
let pos_five = NonZeroI8::new(5)?;
let neg_five = NonZeroI8::new(-5)?;
let min = NonZeroI8::new(i8::MIN)?;
let min_plus_one = NonZeroI8::new(i8::MIN + 1)?;
let max = NonZeroI8::new(i8::MAX)?;
assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);
Run1.71.0 (const: 1.71.0) · sourcepub const fn wrapping_neg(self) -> NonZeroI8
pub const fn wrapping_neg(self) -> NonZeroI8
Wrapping (modular) negation. Computes -self
, wrapping around at the boundary
of the type.
See i8::wrapping_neg
for documentation on overflow behaviour.
Example
let pos_five = NonZeroI8::new(5)?;
let neg_five = NonZeroI8::new(-5)?;
let min = NonZeroI8::new(i8::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
Runsource§impl NonZeroI8
impl NonZeroI8
1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZeroI8) -> Option<NonZeroI8>
pub const fn checked_mul(self, other: NonZeroI8) -> Option<NonZeroI8>
Multiplies two non-zero integers together.
Checks for overflow and returns None
on overflow.
As a consequence, the result cannot wrap to zero.
Examples
let two = NonZeroI8::new(2)?;
let four = NonZeroI8::new(4)?;
let max = NonZeroI8::new(i8::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZeroI8) -> NonZeroI8
pub const fn saturating_mul(self, other: NonZeroI8) -> NonZeroI8
Multiplies two non-zero integers together.
Return NonZeroI8::MAX
on overflow.
Examples
let two = NonZeroI8::new(2)?;
let four = NonZeroI8::new(4)?;
let max = NonZeroI8::new(i8::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Runsourcepub const unsafe fn unchecked_mul(self, other: NonZeroI8) -> NonZeroI8
🔬This is a nightly-only experimental API. (nonzero_ops
#84186)
pub const unsafe fn unchecked_mul(self, other: NonZeroI8) -> NonZeroI8
nonzero_ops
#84186)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > i8::MAX
, or self * rhs < i8::MIN
.
Examples
#![feature(nonzero_ops)]
let two = NonZeroI8::new(2)?;
let four = NonZeroI8::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
Run1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZeroI8>
pub const fn checked_pow(self, other: u32) -> Option<NonZeroI8>
Raises non-zero value to an integer power.
Checks for overflow and returns None
on overflow.
As a consequence, the result cannot wrap to zero.
Examples
let three = NonZeroI8::new(3)?;
let twenty_seven = NonZeroI8::new(27)?;
let half_max = NonZeroI8::new(i8::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
Run1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZeroI8
pub const fn saturating_pow(self, other: u32) -> NonZeroI8
Raise non-zero value to an integer power.
Return NonZeroI8::MIN
or NonZeroI8::MAX
on overflow.
Examples
let three = NonZeroI8::new(3)?;
let twenty_seven = NonZeroI8::new(27)?;
let max = NonZeroI8::new(i8::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Runsource§impl NonZeroI8
impl NonZeroI8
1.70.0 · sourcepub const MIN: NonZeroI8 = _
pub const MIN: NonZeroI8 = _
The smallest value that can be represented by this non-zero
integer type,
equal to i8::MIN
.
Note: While most integer types are defined for every whole
number between MIN
and MAX
, signed non-zero integers are
a special case. They have a “gap” at 0.
Examples
assert_eq!(NonZeroI8::MIN.get(), i8::MIN);
Run1.70.0 · sourcepub const MAX: NonZeroI8 = _
pub const MAX: NonZeroI8 = _
The largest value that can be represented by this non-zero
integer type,
equal to i8::MAX
.
Note: While most integer types are defined for every whole
number between MIN
and MAX
, signed non-zero integers are
a special case. They have a “gap” at 0.
Examples
assert_eq!(NonZeroI8::MAX.get(), i8::MAX);
RunTrait Implementations§
1.45.0 · source§impl BitOrAssign<i8> for NonZeroI8
impl BitOrAssign<i8> for NonZeroI8
source§fn bitor_assign(&mut self, rhs: i8)
fn bitor_assign(&mut self, rhs: i8)
|=
operation. Read more1.45.0 · source§impl BitOrAssign for NonZeroI8
impl BitOrAssign for NonZeroI8
source§fn bitor_assign(&mut self, rhs: NonZeroI8)
fn bitor_assign(&mut self, rhs: NonZeroI8)
|=
operation. Read more1.41.0 · source§impl From<NonZeroI8> for NonZeroI128
impl From<NonZeroI8> for NonZeroI128
source§fn from(small: NonZeroI8) -> NonZeroI128
fn from(small: NonZeroI8) -> NonZeroI128
Converts NonZeroI8
to NonZeroI128
losslessly.
1.41.0 · source§impl From<NonZeroI8> for NonZeroI16
impl From<NonZeroI8> for NonZeroI16
source§fn from(small: NonZeroI8) -> NonZeroI16
fn from(small: NonZeroI8) -> NonZeroI16
Converts NonZeroI8
to NonZeroI16
losslessly.
1.41.0 · source§impl From<NonZeroI8> for NonZeroI32
impl From<NonZeroI8> for NonZeroI32
source§fn from(small: NonZeroI8) -> NonZeroI32
fn from(small: NonZeroI8) -> NonZeroI32
Converts NonZeroI8
to NonZeroI32
losslessly.
1.41.0 · source§impl From<NonZeroI8> for NonZeroI64
impl From<NonZeroI8> for NonZeroI64
source§fn from(small: NonZeroI8) -> NonZeroI64
fn from(small: NonZeroI8) -> NonZeroI64
Converts NonZeroI8
to NonZeroI64
losslessly.
1.41.0 · source§impl From<NonZeroI8> for NonZeroIsize
impl From<NonZeroI8> for NonZeroIsize
source§fn from(small: NonZeroI8) -> NonZeroIsize
fn from(small: NonZeroI8) -> NonZeroIsize
Converts NonZeroI8
to NonZeroIsize
losslessly.
source§impl Ord for NonZeroI8
impl Ord for NonZeroI8
source§impl PartialEq for NonZeroI8
impl PartialEq for NonZeroI8
source§impl PartialOrd for NonZeroI8
impl PartialOrd for NonZeroI8
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read more1.49.0 · source§impl TryFrom<NonZeroI128> for NonZeroI8
impl TryFrom<NonZeroI128> for NonZeroI8
source§fn try_from(
value: NonZeroI128
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI128>>::Error>
fn try_from( value: NonZeroI128 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI128>>::Error>
Attempts to convert NonZeroI128
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI16> for NonZeroI8
impl TryFrom<NonZeroI16> for NonZeroI8
source§fn try_from(
value: NonZeroI16
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI16>>::Error>
fn try_from( value: NonZeroI16 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI16>>::Error>
Attempts to convert NonZeroI16
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroI8
impl TryFrom<NonZeroI32> for NonZeroI8
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI64> for NonZeroI8
impl TryFrom<NonZeroI64> for NonZeroI8
source§fn try_from(
value: NonZeroI64
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI64>>::Error>
fn try_from( value: NonZeroI64 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI64>>::Error>
Attempts to convert NonZeroI64
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI8> for NonZeroU128
impl TryFrom<NonZeroI8> for NonZeroU128
source§fn try_from(
value: NonZeroI8
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI8>>::Error>
fn try_from( value: NonZeroI8 ) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI8>>::Error>
Attempts to convert NonZeroI8
to NonZeroU128
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI8> for NonZeroU16
impl TryFrom<NonZeroI8> for NonZeroU16
source§fn try_from(
value: NonZeroI8
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI8>>::Error>
fn try_from( value: NonZeroI8 ) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI8>>::Error>
Attempts to convert NonZeroI8
to NonZeroU16
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI8> for NonZeroU32
impl TryFrom<NonZeroI8> for NonZeroU32
source§fn try_from(
value: NonZeroI8
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI8>>::Error>
fn try_from( value: NonZeroI8 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI8>>::Error>
Attempts to convert NonZeroI8
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI8> for NonZeroU64
impl TryFrom<NonZeroI8> for NonZeroU64
source§fn try_from(
value: NonZeroI8
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI8>>::Error>
fn try_from( value: NonZeroI8 ) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI8>>::Error>
Attempts to convert NonZeroI8
to NonZeroU64
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI8> for NonZeroUsize
impl TryFrom<NonZeroI8> for NonZeroUsize
source§fn try_from(
value: NonZeroI8
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI8>>::Error>
fn try_from( value: NonZeroI8 ) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI8>>::Error>
Attempts to convert NonZeroI8
to NonZeroUsize
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroIsize> for NonZeroI8
impl TryFrom<NonZeroIsize> for NonZeroI8
source§fn try_from(
value: NonZeroIsize
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroIsize>>::Error>
fn try_from( value: NonZeroIsize ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroIsize>>::Error>
Attempts to convert NonZeroIsize
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU128> for NonZeroI8
impl TryFrom<NonZeroU128> for NonZeroI8
source§fn try_from(
value: NonZeroU128
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU128>>::Error>
fn try_from( value: NonZeroU128 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU128>>::Error>
Attempts to convert NonZeroU128
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU16> for NonZeroI8
impl TryFrom<NonZeroU16> for NonZeroI8
source§fn try_from(
value: NonZeroU16
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU16>>::Error>
fn try_from( value: NonZeroU16 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU16>>::Error>
Attempts to convert NonZeroU16
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU32> for NonZeroI8
impl TryFrom<NonZeroU32> for NonZeroI8
source§fn try_from(
value: NonZeroU32
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU32>>::Error>
fn try_from( value: NonZeroU32 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU32>>::Error>
Attempts to convert NonZeroU32
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU64> for NonZeroI8
impl TryFrom<NonZeroU64> for NonZeroI8
source§fn try_from(
value: NonZeroU64
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU64>>::Error>
fn try_from( value: NonZeroU64 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU64>>::Error>
Attempts to convert NonZeroU64
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroUsize> for NonZeroI8
impl TryFrom<NonZeroUsize> for NonZeroI8
source§fn try_from(
value: NonZeroUsize
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroUsize>>::Error>
fn try_from( value: NonZeroUsize ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroUsize>>::Error>
Attempts to convert NonZeroUsize
to NonZeroI8
.