Struct dactyl::GreaterThanZero

pub struct GreaterThanZero<T>(_)
 where
    T: GtZero;

Greater Than Zero

GreaterThanZero is a memory-saving replacement for Option<T> where T is only “some” if it is > 0 (and not NAN or NEG_INFINITY). In other words, GreaterThanZero<T> has the same size as T.

It is similar to the std::num::NonZeroX types, except it is its own Option so does not need to be wrapped (it is infallible). Instead of is_some, you’d use GreaterThanZero::is_gt_zero.

To obtain the underlying primitive, you can use GreaterThanZero::get to ensure the value is “some”, or GreaterThanZero::get_unchecked to return the value regardless of zeroness. (Dereferencing also returns the unchecked value, albeit as a reference.)

Non-qualifying values are stored regardless and can be obtained by dereferencing or GreaterThanZero::get_unchecked.

Other neat things: this struct implements Add, Div, Mul, Rem, Sub, and the corresponding *Assign traits, so you can manipulate values in place. Zeroness is always evaluated in realtime, so this works even in cases where the result crosses that line.

It also implements Option-like methods GreaterThanZero::filter, GreaterThanZero::map, GreaterThanZero::replace, and GreaterThanZero::zip.

Examples

use dactyl::GreaterThanZero;

let gt0 = GreaterThanZero::from(-3_isize);
assert!(! gt0.is_gt_zero());
assert_eq!(gt0.get(), None);
assert_eq!(gt0.get_unchecked(), -3_isize);

let gt1 = GreaterThanZero::from(5.5_f64);
assert!(gt1.is_gt_zero());
assert_eq!(gt1.get(), Some(5.5_f64));
assert_eq!(gt1.get_unchecked(), 5.5_f64);

Implementations

impl<T: GtZero> GreaterThanZero<T>

pub fn filter<F>(self, f: F) -> Self where
    F: FnOnce(T) -> bool, 

Filter.

Like std::option::Option::filter, this will evaluate the instance value with your callback, leaving it as-was if true, or zeroing it out if false.

Examples

use dactyl::GreaterThanZero;

// This filter is not applied as the value is not > 0.
assert_eq!(
    GreaterThanZero::from(-3_isize).filter(|x| x != 4),
    GreaterThanZero::from(-3_isize)
);

// This filter is applied and fails, zeroing the value.
assert_eq!(
    GreaterThanZero::from(4_u8).filter(|x| x != 4),
    GreaterThanZero::from(0_u8)
);

// This filter is applied and passes, keeping the original value.
assert_eq!(
    GreaterThanZero::from(32_u32).filter(|x| x != 4),
    GreaterThanZero::from(32_u32)
);

pub fn get(self) -> Option<T>

Get Inner Value.

This will return Some(T) if the value is greater than zero, otherwise None.

pub fn get_unchecked(self) -> T

Get Unchecked.

This will return the inner value regardless of its greater-than- zeroness. This is equivalent to dereferencing with copy.

pub fn is_gt_zero(&self) -> bool

Is Greater Than Zero.

This will return true if the value is > 0, not NAN, and not NEG_INFINITY.

pub fn map<F>(self, f: F) -> Self where
    F: FnOnce(T) -> T, 

Map.

Operate on the inner value if it is greater than zero, otherwise do nothing. This is equivalent to std::option::Option::map, except that the returned value can be less than or equal to zero (our equivalent of None).

Examples

use dactyl::GreaterThanZero;

// Turn 4 to 8.
assert_eq!(
    GreaterThanZero::from(4_u8).map(|_| 8),
    GreaterThanZero::from(8_u8)
);

pub fn replace(&mut self, b: T)

Replace.

This is a convenience method allowing the inner value to be replaced with any arbitrary value. As this type is Copy, you could avoid the &mut and just reassign.

pub fn zip<U: GtZero>(self, b: GreaterThanZero<U>) -> Option<(T, U)>

Zip.

Produce a tuple of the inner value of A and B if both are greater than zero. This is comparable to std::option::Option::zip except that the inner types of A and B are allowed to be different.

Trait Implementations

impl<T: GtZero + Add<Output = T>> Add<GreaterThanZero<T>> for GreaterThanZero<T>

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: GtZero + AddAssign> AddAssign<GreaterThanZero<T>> for GreaterThanZero<T>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Clone> Clone for GreaterThanZero<T> where
    T: GtZero, 

fn clone(&self) -> GreaterThanZero<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for GreaterThanZero<T> where
    T: GtZero, 

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

Formats the value using the given formatter.

impl<T: GtZero> Default for GreaterThanZero<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: GtZero> Deref for GreaterThanZero<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: GtZero> DerefMut for GreaterThanZero<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: GtZero + Display> Display for GreaterThanZero<T>

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

Formats the value using the given formatter.

impl<T: GtZero + Div<Output = T>> Div<GreaterThanZero<T>> for GreaterThanZero<T>

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: GtZero + DivAssign> DivAssign<GreaterThanZero<T>> for GreaterThanZero<T>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T: GtZero + FromStr> From<&'_ str> for GreaterThanZero<T>

fn from(src: &str) -> Self

Performs the conversion.

impl From<NonZeroI128> for GreaterThanZero<i128>

fn from(src: NonZeroI128) -> Self

Performs the conversion.

impl From<NonZeroI16> for GreaterThanZero<i16>

fn from(src: NonZeroI16) -> Self

Performs the conversion.

impl From<NonZeroI32> for GreaterThanZero<i32>

fn from(src: NonZeroI32) -> Self

Performs the conversion.

impl From<NonZeroI64> for GreaterThanZero<i64>

fn from(src: NonZeroI64) -> Self

Performs the conversion.

impl From<NonZeroI8> for GreaterThanZero<i8>

fn from(src: NonZeroI8) -> Self

Performs the conversion.

impl From<NonZeroIsize> for GreaterThanZero<isize>

fn from(src: NonZeroIsize) -> Self

Performs the conversion.

impl From<NonZeroU128> for GreaterThanZero<u128>

fn from(src: NonZeroU128) -> Self

Performs the conversion.

impl From<NonZeroU16> for GreaterThanZero<u16>

fn from(src: NonZeroU16) -> Self

Performs the conversion.

impl From<NonZeroU32> for GreaterThanZero<u32>

fn from(src: NonZeroU32) -> Self

Performs the conversion.

impl From<NonZeroU64> for GreaterThanZero<u64>

fn from(src: NonZeroU64) -> Self

Performs the conversion.

impl From<NonZeroU8> for GreaterThanZero<u8>

fn from(src: NonZeroU8) -> Self

Performs the conversion.

impl From<NonZeroUsize> for GreaterThanZero<usize>

fn from(src: NonZeroUsize) -> Self

Performs the conversion.

impl<T: GtZero> From<T> for GreaterThanZero<T>

fn from(src: T) -> Self

Performs the conversion.

impl<T: GtZero + Hash> Hash for GreaterThanZero<T>

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, 

Feeds a slice of this type into the given Hasher.

impl<T: GtZero + Mul<Output = T>> Mul<GreaterThanZero<T>> for GreaterThanZero<T>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: GtZero + MulAssign> MulAssign<GreaterThanZero<T>> for GreaterThanZero<T>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T: GtZero + Ord> Ord for GreaterThanZero<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

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

Compares and returns the maximum of two values.

#[must_use]

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

Compares and returns the minimum of two values.

#[must_use]

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

Restrict a value to a certain interval.

impl<T: GtZero> PartialEq<GreaterThanZero<T>> for GreaterThanZero<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<T: GtZero> PartialEq<T> for GreaterThanZero<T>

fn eq(&self, other: &T) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<T: GtZero> PartialOrd<GreaterThanZero<T>> for GreaterThanZero<T>

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

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

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

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

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

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

impl<T: GtZero + Rem<Output = T>> Rem<GreaterThanZero<T>> for GreaterThanZero<T>

type Output = Self

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: GtZero + RemAssign> RemAssign<GreaterThanZero<T>> for GreaterThanZero<T>

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<T: GtZero + Sub<Output = T>> Sub<GreaterThanZero<T>> for GreaterThanZero<T>

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: GtZero + SubAssign> SubAssign<GreaterThanZero<T>> for GreaterThanZero<T>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T: Copy> Copy for GreaterThanZero<T> where
    T: GtZero, 

impl<T: GtZero> Eq for GreaterThanZero<T>