Type Alias NonZeroU32 

pub type NonZeroU32 = NonZero<u32>;

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

---

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

---

---

📜
A u32 that is known not to equal zero.

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

assert_eq!(size_of::<Option<core::num::NonZeroU32>>(), size_of::<u32>());

Layout

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

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

use std::num::NonZeroU32;

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

Compile-time creation

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

use std::num::NonZeroU32;

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

Aliased Type

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

Trait Implementations

impl BitSized<32> for NonZeroU32

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 NonZeroU32

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 NonZeroU32

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

Features

Makes use of the unsafe_niche feature if enabled.

type Inner = u32

The internal representation of this numeric type.

type Out = NonZero<u32>

The output type for operations.

type Rhs = NonZero<u32>

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 NonZeroU32

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

The additive identity (0), if applicable.

const NUM_ONE: Option<NonZeroU32>

The multiplicative identity (1).

const NUM_TWO: Option<NonZeroU32>

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

const NUM_THREE: Option<NonZeroU32>

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

const NUM_NEG_ONE: Option<NonZeroU32> = None

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

const NUM_MIN: Option<NonZeroU32>

The smallest representable value.

const NUM_MAX: Option<NonZeroU32>

The greatest representable value.

const NUM_MIN_POSITIVE: Option<NonZeroU32>

The smallest representable positive value.

const NUM_MAX_NEGATIVE: Option<NonZeroU32> = None

The greatest representable negative value, if applicable.

const NUM_MIN_NORM: Option<NonZeroU32>

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

const NUM_MAX_NORM: Option<NonZeroU32>

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

const NUM_MAX_POWER_OF_TWO: Option<NonZeroU32>

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

type Num = NonZero<u32>

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.