Type Alias NonZeroI8

pub type NonZeroI8 = NonZero<i8>;

core A signed integer that is known not to equal zero.

Re-exported from core::num:: .

---

An i8 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>());

Layout

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

Aliased Type

struct NonZeroI8(/* private fields */);

Trait Implementations

impl BitSized<8> for NonZeroI8

const BIT_SIZE: usize = _

The bit size of this type (only the relevant data part, without padding).

const MIN_BYTE_SIZE: usize = _

The rounded up byte size for this type.

fn bit_size(&self) -> usize

Returns the bit size of this type (only the relevant data part, without padding).

fn min_byte_size(&self) -> usize

Returns the rounded up byte size for this type.

impl Num for NonZeroI8

Available on crate feature _int_i8 only.

fn num_set_one(&mut self) -> Result<()>

Features

Makes use of the unsafe_niche feature if enabled.

type Inner = i8

The internal representation of this numeric type.

type Out = NonZero<i8>

The output type for operations.

type Rhs = NonZero<i8>

The right hand side type for operations.

fn num_into(self) -> Self::Inner

Returns the inner self representation.

fn num_from(from: Self::Inner) -> Result<Self>

Returns Self if given a valid value.

fn num_from_ref(from: &Self::Inner) -> Result<Self>

Returns Self if given a valid &value.

fn num_set(&mut self, value: Self::Inner) -> Result<()>

Sets self to the given valid value.

fn num_set_ref(&mut self, value: &Self::Inner) -> Result<()>

Sets self to the given valid &value.

fn num_is_zero(&self) -> Result<bool>

Returns true if self is zero.

fn num_is_one(&self) -> Result<bool>

Returns true if self is one.

fn num_get_zero() -> Result<Self>

Returns the number zero.

fn num_get_one() -> Result<Self>

Returns the number one.

fn num_set_zero(&mut self) -> Result<()>

Sets self to 0.

fn num_mul(self, other: Self) -> Result<Self::Out>

Computes self * rhs (multiplication).

fn num_ref_mul(&self, other: &Self) -> Result<Self::Out>

Like num_mul but takes the arguments by reference.

fn num_ref_mul_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self *= rhs; (multiplication).

fn num_neg(self) -> Result<Self::Out>

Computes -self (additive inverse).

fn num_ref_neg(&self) -> Result<Self::Out>

Like num_neg but takes the arguments by reference.

fn num_abs(self) -> Result<Self::Out>

Computes |self| (absolute value).

fn num_ref_abs(&self) -> Result<Self::Out>

Like num_abs but takes the arguments by reference.

fn num_add(self, other: Self) -> Result<Self::Out>

Computes self + rhs (addition).

fn num_ref_add(&self, other: &Self) -> Result<Self::Out>

Like num_add but takes the arguments by reference.

fn num_ref_add_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self += rhs; (addition).

fn num_sub(self, other: Self) -> Result<Self::Out>

Computes self - rhs (subtraction).

fn num_ref_sub(&self, other: &Self) -> Result<Self::Out>

Like num_sub but takes the arguments by reference.

fn num_ref_sub_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self -= rhs; (subtraction).

fn num_div(self, other: Self) -> Result<Self::Out>

Computes self / rhs (division).

fn num_ref_div(&self, other: &Self) -> Result<Self::Out>

Like num_div but takes the arguments by reference.

fn num_ref_div_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self /= rhs; (division).

fn num_rem(self, other: Self) -> Result<Self::Out>

Computes self % rhs (remainder).

fn num_ref_rem(&self, other: &Self) -> Result<Self::Out>

Like num_rem but takes the arguments by reference.

fn num_ref_rem_assign(&mut self, other: &Self) -> Result<()>

Computes &mut self %= rhs; (remainder).