Struct NonNU8 

pub struct NonNU8<const N: u8>(/* private fields */);

8-bit unsigned integer type that is known not to equal to any single value N.

This enables some memory layout optimization. For example, Option<NonNU8<N>> is the same size as u8:

use std::mem::size_of;
assert_eq!(size_of::<Option<NonNU8<42>>>(), size_of::<u8>());

Layout

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

Note that this does not mean you can transmute this type to get a u8 of the same value. If you need an u8 of the same value, use NonNU8::get instead.

Implementations

impl<const N: u8> NonNU8<N>

pub const MIN: Self

The smallest value that can be represented by this non-N integer type.

pub const MAX: Self

The largest value that can be represented by this non-N integer type.

pub const BITS: u32 = 8u32

The size of this non-N integer type in bits.

This value is equal to u8::BITS.

Examples

assert_eq!(NonNU8::<42>::BITS, u8::BITS);

pub const fn new(n: u8) -> Option<Self>

Creates a non-N if the given value is not N.

pub const unsafe fn new_unchecked(n: u8) -> Self

Creates a NonNU8<N> without checking whether the value is non-N. This results in undefined behaviour if the value is N.

Safety

The value must not be N.

pub const fn get(self) -> u8

Returns the value as a primitive type.

pub const fn cast<const M: u8>(self) -> Option<NonNU8<M>>

Returns a new NonNU8<M> with the current value if it is not M.

pub const unsafe fn cast_unchecked<const M: u8>(self) -> NonNU8<M>

Returns a new NonNU8<M> with the current value without checking whether it is not M. This results in undefined behaviour if the current value is M.

Safety

The current value must not be M.

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

Examples

Basic usage:

let n = NonNU8::<42>::new(u8::MAX).unwrap();

assert_eq!(n.leading_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

Examples

Basic usage:

let n = NonNU8::<42>::new(0b0101000).unwrap();

assert_eq!(n.trailing_zeros(), 3);

pub const fn checked_mul(self, other: Self) -> Option<Self>

Multiplies two non-N integers together. Checks for overflow and returns None on overflow.

Examples

let two = NonNU8::<42>::new(2).unwrap();
let four = NonNU8::<42>::new(4).unwrap();
let max = NonNU8::<42>::new(u8::MAX).unwrap();

assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));

pub const fn saturating_mul(self, other: Self) -> Self

Multiplies two non-N integers together. Return NonNU8::<42>::MAX on overflow.

Examples

let two = NonNU8::<42>::new(2)?;
let four = NonNU8::<42>::new(4)?;
let max = NonNU8::<42>::new(u8::MAX)?;

assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));

pub const fn checked_pow(self, other: u32) -> Option<Self>

Multiplies two non-N 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-N value. The behaviour is undefined as soon as self * rhs > u8::MAX. Raises non-N value to an integer power. Checks for overflow and returns None on overflow.

Examples

let three = NonNU8::<42>::new(3)?;
let twenty_seven = NonNU8::<42>::new(27)?;
let half_max = NonNU8::<42>::new(u8::MAX / 2)?;

assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));

pub const fn saturating_pow(self, other: u32) -> Self

Raise non-N value to an integer power. Return NonNU8::<42>::MAX on overflow.

Examples

let three = NonNU8::<42>::new(3)?;
let twenty_seven = NonNU8::<42>::new(27)?;
let max = NonNU8::<42>::new(u8::MAX)?;

assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));

pub const fn is_power_of_two(self) -> bool

Returns true if and only if self == (1 << k) for some k.

Examples

Basic usage:

let eight = NonNU8::<42>::new(8).unwrap();
assert!(eight.is_power_of_two());
let ten = NonNU8::<42>::new(10).unwrap();
assert!(!ten.is_power_of_two());

pub const fn checked_add(self, other: u8) -> Option<Self>

Adds an unsigned integer to a non-N value. Checks for overflow and returns None on overflow.

Examples

let one = NonNU8::<42>::new(1)?;
let two = NonNU8::<42>::new(2)?;
let max = NonNU8::<42>::new(u8::MAX)?;

assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));

pub const fn saturating_add(self, other: u8) -> Self

Adds an unsigned integer to a non-N value. Return NonNU8::MAX on overflow.

Examples

let one = NonNU8::<42>::new(1)?;
let two = NonNU8::<42>::new(2)?;
let max = NonNU8::<42>::new(u8::MAX)?;

assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));

pub const fn checked_next_power_of_two(self) -> Option<Self>

Returns the smallest power of two greater than or equal to n. Checks for overflow and returns None if the next power of two is greater than the type’s maximum value.

Examples

let two = NonNU8::<42>::new(2)?;
let three = NonNU8::<42>::new(3)?;
let four = NonNU8::<42>::new(4)?;
let max = NonNU8::<42>::new(u8::MAX)?;

assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );

pub const fn ilog2(self) -> u32

Returns the base 2 logarithm of the number, rounded down. u8::ilog2,

Examples

assert_eq!(NonNU8::<42>::new(7).unwrap().ilog2(), 2);
assert_eq!(NonNU8::<42>::new(8).unwrap().ilog2(), 3);
assert_eq!(NonNU8::<42>::new(9).unwrap().ilog2(), 3);

pub const fn ilog10(self) -> u32

Returns the base 10 logarithm of the number, rounded down. u8::ilog10,

Examples

assert_eq!(NonNU8::<42>::new(99).unwrap().ilog10(), 1);
assert_eq!(NonNU8::<42>::new(100).unwrap().ilog10(), 2);
assert_eq!(NonNU8::<42>::new(101).unwrap().ilog10(), 2);

Trait Implementations

impl<const N: u8, const M: u8> Add<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the + operator.

fn add(self, rhs: NonNU8<M>) -> Self::Output

Performs the + operation.

impl<const N: u8> Add<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<const N: u8, const M: u8> AddAssign<NonNU8<M>> for NonNU8<N>

fn add_assign(&mut self, rhs: NonNU8<M>)

Performs the += operation.

impl<const N: u8> AddAssign<u8> for NonNU8<N>

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const N: u8> Binary for NonNU8<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: u8, const M: u8> BitAnd<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the & operator.

fn bitand(self, rhs: NonNU8<M>) -> Self::Output

Performs the & operation.

impl<const N: u8> BitAnd<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> Self::Output

Performs the & operation.

impl<const N: u8, const M: u8> BitAndAssign<NonNU8<M>> for NonNU8<N>

fn bitand_assign(&mut self, rhs: NonNU8<M>)

Performs the &= operation.

impl<const N: u8> BitAndAssign<u8> for NonNU8<N>

fn bitand_assign(&mut self, rhs: u8)

Performs the &= operation.

impl<const N: u8, const M: u8> BitOr<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the | operator.

fn bitor(self, rhs: NonNU8<M>) -> Self::Output

Performs the | operation.

impl<const N: u8> BitOr<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> Self::Output

Performs the | operation.

impl<const N: u8, const M: u8> BitOrAssign<NonNU8<M>> for NonNU8<N>

fn bitor_assign(&mut self, rhs: NonNU8<M>)

Performs the |= operation.

impl<const N: u8> BitOrAssign<u8> for NonNU8<N>

fn bitor_assign(&mut self, rhs: u8)

Performs the |= operation.

impl<const N: u8, const M: u8> BitXor<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: NonNU8<M>) -> Self::Output

Performs the ^ operation.

impl<const N: u8> BitXor<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> Self::Output

Performs the ^ operation.

impl<const N: u8, const M: u8> BitXorAssign<NonNU8<M>> for NonNU8<N>

fn bitxor_assign(&mut self, rhs: NonNU8<M>)

Performs the ^= operation.

impl<const N: u8> BitXorAssign<u8> for NonNU8<N>

fn bitxor_assign(&mut self, rhs: u8)

Performs the ^= operation.

impl<const N: u8> Clone for NonNU8<N>

fn clone(&self) -> NonNU8<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: u8> Debug for NonNU8<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: u8> Display for NonNU8<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: u8, const M: u8> Div<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the / operator.

fn div(self, rhs: NonNU8<M>) -> Self::Output

Performs the / operation.

impl<const N: u8> Div<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<const N: u8, const M: u8> DivAssign<NonNU8<M>> for NonNU8<N>

fn div_assign(&mut self, rhs: NonNU8<M>)

Performs the /= operation.

impl<const N: u8> DivAssign<u8> for NonNU8<N>

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const N: u8> From<NonNU8<N>> for u8

fn from(nonn: NonNU8<N>) -> Self

Converts a NonNU8 into an u8

impl<const N: u8> FromStr for NonNU8<N>

type Err = ParseIntError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<const N: u8> Hash for NonNU8<N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: u8> LowerHex for NonNU8<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: u8, const M: u8> Mul<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNU8<M>) -> Self::Output

Performs the * operation.

impl<const N: u8> Mul<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<const N: u8, const M: u8> MulAssign<NonNU8<M>> for NonNU8<N>

fn mul_assign(&mut self, rhs: NonNU8<M>)

Performs the *= operation.

impl<const N: u8> MulAssign<u8> for NonNU8<N>

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const N: u8> Not for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const N: u8> Octal for NonNU8<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: u8> Ord for NonNU8<N>

fn cmp(&self, other: &NonNU8<N>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const N: u8> PartialEq for NonNU8<N>

fn eq(&self, other: &NonNU8<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: u8> PartialOrd for NonNU8<N>

fn partial_cmp(&self, other: &NonNU8<N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const N: u8, const M: u8> Rem<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the % operator.

fn rem(self, rhs: NonNU8<M>) -> Self::Output

Performs the % operation.

impl<const N: u8> Rem<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<const N: u8, const M: u8> RemAssign<NonNU8<M>> for NonNU8<N>

fn rem_assign(&mut self, rhs: NonNU8<M>)

Performs the %= operation.

impl<const N: u8> RemAssign<u8> for NonNU8<N>

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl<const N: u8, const M: u8> Shl<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the << operator.

fn shl(self, rhs: NonNU8<M>) -> Self::Output

Performs the << operation.

impl<const N: u8> Shl<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> Self::Output

Performs the << operation.

impl<const N: u8, const M: u8> ShlAssign<NonNU8<M>> for NonNU8<N>

fn shl_assign(&mut self, rhs: NonNU8<M>)

Performs the <<= operation.

impl<const N: u8> ShlAssign<u8> for NonNU8<N>

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl<const N: u8, const M: u8> Shr<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the >> operator.

fn shr(self, rhs: NonNU8<M>) -> Self::Output

Performs the >> operation.

impl<const N: u8> Shr<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> Self::Output

Performs the >> operation.

impl<const N: u8, const M: u8> ShrAssign<NonNU8<M>> for NonNU8<N>

fn shr_assign(&mut self, rhs: NonNU8<M>)

Performs the >>= operation.

impl<const N: u8> ShrAssign<u8> for NonNU8<N>

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl<const N: u8, const M: u8> Sub<NonNU8<M>> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the - operator.

fn sub(self, rhs: NonNU8<M>) -> Self::Output

Performs the - operation.

impl<const N: u8> Sub<u8> for NonNU8<N>

type Output = NonNU8<N>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<const N: u8, const M: u8> SubAssign<NonNU8<M>> for NonNU8<N>

fn sub_assign(&mut self, rhs: NonNU8<M>)

Performs the -= operation.

impl<const N: u8> SubAssign<u8> for NonNU8<N>

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const N: u8> UpperHex for NonNU8<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: u8> Copy for NonNU8<N>

impl<const N: u8> Eq for NonNU8<N>

impl<const N: u8> StructuralPartialEq for NonNU8<N>