Type Alias NonZeroUsize 

pub type NonZeroUsize = NonZero<usize>;

𝟙 ⚗️ core An unsigned integer that is known not to equal zero.

Re-exported from core::num:: .

---

A usize that is known not to equal zero.

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

assert_eq!(size_of::<Option<core::num::NonZeroUsize>>(), size_of::<usize>());

Layout

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

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

use std::num::NonZeroUsize;

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

Aliased Type

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

Trait Implementations

impl BitSized<64> for NonZeroUsize

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 NonZeroUsize

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

Features

Makes use of the unsafe_niche feature if enabled.

type Inner = usize

The internal representation of this numeric type.

type Out = NonZero<usize>

The output type for operations.

type Rhs = NonZero<usize>

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

fn num_abs(self) -> Result<Self>

Computes |self| (absolute value).

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

Like num_abs but takes the arguments by reference.

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

where Self: Sized,

Computes -self (additive inverse).

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

Like num_neg but takes the arguments by reference.

impl NumConst for NonZeroUsize

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 = false

Whether the number includes the sign.

const NUM_IS_NICHE: bool = true

Whether the number has a memory niche optimization.

const NUM_ZERO: Option<NonZeroUsize>

The additive identity (0), if applicable.

const NUM_ONE: Option<NonZeroUsize>

The multiplicative identity (1).

const NUM_TWO: Option<NonZeroUsize>

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

const NUM_THREE: Option<NonZeroUsize>

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

const NUM_NEG_ONE: Option<NonZeroUsize> = None

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

const NUM_MIN: Option<NonZeroUsize>

The smallest representable value.

const NUM_MAX: Option<NonZeroUsize>

The greatest representable value.

const NUM_MIN_POSITIVE: Option<NonZeroUsize>

The smallest representable positive value.

const NUM_MAX_NEGATIVE: Option<NonZeroUsize> = None

The greatest representable negative value, if applicable.

const NUM_MIN_NORM: Option<NonZeroUsize>

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

const NUM_MAX_NORM: Option<NonZeroUsize>

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

const NUM_MAX_POWER_OF_TWO: Option<NonZeroUsize>

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

type Num = NonZero<usize>

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.