Type Alias NonZeroIsize 

pub type NonZeroIsize = NonZero<isize>;

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

---

^{📍num/grain/niche re-exported from core::num}

---

---

📜
An isize that is known not to equal zero.

This enables some memory layout optimization. For example, Option<NonZeroIsize> is the same size as isize:

assert_eq!(size_of::<Option<core::num::NonZeroIsize>>(), size_of::<isize>());

Layout

NonZeroIsize is guaranteed to have the same layout and bit validity as isize with the exception that 0 is not a valid instance. Option<NonZeroIsize> is guaranteed to be compatible with isize, including in FFI.

Thanks to the null pointer optimization, NonZeroIsize and Option<NonZeroIsize> are guaranteed to have the same size and alignment:

use std::num::NonZeroIsize;

assert_eq!(size_of::<NonZeroIsize>(), size_of::<Option<NonZeroIsize>>());
assert_eq!(align_of::<NonZeroIsize>(), align_of::<Option<NonZeroIsize>>());

Compile-time creation

Since both Option::unwrap() and Option::expect() are const, it is possible to define a new NonZeroIsize at compile time via:

use std::num::NonZeroIsize;

const TEN: NonZeroIsize = NonZeroIsize::new(10).expect("ten is non-zero");

Aliased Type

pub struct NonZeroIsize(/* private fields */);

Trait Implementations

impl BitSized<64> for NonZeroIsize

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 ConstInit for NonZeroIsize

This implementation returns the same as Self::MIN.

const INIT: Self = Self::MIN

Returns the compile-time “initial value” for a type.

impl Num for NonZeroIsize

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

Features

Makes use of the unsafe_niche feature if enabled.

type Inner = isize

The internal representation of this numeric type.

type Out = NonZero<isize>

The output type for operations.

type Rhs = NonZero<isize>

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

impl NumConst for NonZeroIsize

const NUM_IS_BIG: bool = false

Whether the number can represent big quantities.

const NUM_IS_INT: bool = true

Whether the number uses an integer representation.

const NUM_IS_FLOAT: bool = false

Whether the number uses a floating-point representation.

const NUM_IS_FIXED: bool = false

Whether the number uses a fixed-point representation.

const NUM_IS_SIGNED: bool = true

Whether the number includes the sign.

const NUM_IS_NICHE: bool = true

Whether the number has a memory niche optimization.

const NUM_ZERO: Option<NonZeroIsize>

The additive identity (0), if applicable.

const NUM_ONE: Option<NonZeroIsize>

The multiplicative identity (1).

const NUM_TWO: Option<NonZeroIsize>

The only even prime and the fundamental doubling factor (2).

const NUM_THREE: Option<NonZeroIsize>

The smallest odd prime and the first nontrivial divisor (3).

const NUM_NEG_ONE: Option<NonZeroIsize>

The additive inverse of ONE (-1), if applicable.

const NUM_MIN: Option<NonZeroIsize>

The smallest representable value.

const NUM_MAX: Option<NonZeroIsize>

The greatest representable value.

const NUM_MIN_POSITIVE: Option<NonZeroIsize>

The smallest representable positive value.

const NUM_MAX_NEGATIVE: Option<NonZeroIsize>

The greatest representable negative value, if applicable.

const NUM_MIN_NORM: Option<NonZeroIsize>

The smallest normalized value (e.g. 0.0 for float, MIN for integers).

const NUM_MAX_NORM: Option<NonZeroIsize>

The greatest normalized value (e.g. 1.0 for float, MAX for integers).

const NUM_MAX_POWER_OF_TWO: Option<NonZeroIsize>

The maximum representable power of two within the type’s range.

type Num = NonZero<isize>

The underlying numeric type implementing this trait.

fn is_num_zero(&self) -> bool

Whether self is equal to NUM_ZERO.

fn is_num_one(&self) -> bool

Whether self is equal to NUM_ONE.

fn is_num_two(&self) -> bool

Whether self is equal to NUM_TWO.

fn is_num_three(&self) -> bool

Whether self is equal to NUM_THREE.

fn is_num_neg_one(&self) -> bool

Whether self is equal to NUM_NEG_ONE.

fn is_num_min(&self) -> bool

Whether self is equal to NUM_MIN.

fn is_num_max(&self) -> bool

Whether self is equal to NUM_MAX.

fn is_num_min_positive(&self) -> bool

Whether self is equal to Some(NUM_MIN_POSITIVE).

fn is_num_max_negative(&self) -> bool

Whether self is equal to NUM_MAX_NEGATIVE.

fn is_num_min_norm(&self) -> bool

Whether self is equal to NUM_MIN_NORM.

fn is_num_max_norm(&self) -> bool

Whether self is equal to NUM_MAX_NORM.

fn is_num_max_power_of_two(&self) -> bool

Whether self is equal to NUM_MAX_POWER_OF_TWO.