Enum PositiveIntegers 

#[non_exhaustive]
pub enum PositiveIntegers {
    _8(PositiveInteger8),
    _16(PositiveInteger16),
    _32(PositiveInteger32),
    _64(PositiveInteger64),
    _128(PositiveInteger128),
}

The family of positive integers, also known as Pz.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

_8(PositiveInteger8)

_16(PositiveInteger16)

_32(PositiveInteger32)

_64(PositiveInteger64)

_128(PositiveInteger128)

Trait Implementations

impl Bound for PositiveIntegers

This implementation defers to the actual integer variant.

fn is_lower_bounded(&self) -> bool

Returns true if the number is lower bounded.

fn is_upper_bounded(&self) -> bool

Returns true if the number is upper bounded.

fn lower_bound(&self) -> Option<Self>

Returns the lower bound, if any.

fn upper_bound(&self) -> Option<Self>

Returns the upper bound, if any.

impl Clone for PositiveIntegers

fn clone(&self) -> PositiveIntegers

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConstLowerBounded for PositiveIntegers

const MIN: Self

Returns a PositiveInteger8::MIN.

impl ConstOne for PositiveIntegers

const ONE: Self

Returns a PositiveInteger8::ONE.

impl ConstUpperBounded for PositiveIntegers

const MAX: Self

Returns a PositiveInteger128::MAX.

impl Count for PositiveIntegers

fn is_countable(&self) -> bool

All integers are countable.

fn is_uncountable(&self) -> bool

Returns false if the number is countable.

impl Countable for PositiveIntegers

This implementation defers to the actual integer variant.

fn next(&self) -> NumeraResult<Self>

Returns the next countable value.

fn previous(&self) -> NumeraResult<Self>

Returns the previous countable value.

impl Debug for PositiveIntegers

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

Formats the value using the given formatter.

impl From<PositiveInteger128> for PositiveIntegers

fn from(z: PositiveInteger128) -> PositiveIntegers

Converts to this type from the input type.

impl From<PositiveInteger16> for PositiveIntegers

fn from(z: PositiveInteger16) -> PositiveIntegers

Converts to this type from the input type.

impl From<PositiveInteger32> for PositiveIntegers

fn from(z: PositiveInteger32) -> PositiveIntegers

Converts to this type from the input type.

impl From<PositiveInteger64> for PositiveIntegers

fn from(z: PositiveInteger64) -> PositiveIntegers

Converts to this type from the input type.

impl From<PositiveInteger8> for PositiveIntegers

fn from(z: PositiveInteger8) -> PositiveIntegers

Converts to this type from the input type.

impl From<PositiveIntegers> for AllIntegers

fn from(z: PositiveIntegers) -> AllIntegers

Converts to this type from the input type.

impl Ident for PositiveIntegers

This implementation defers to the actual integer variant.

fn can_zero(&self) -> bool

Returns true if the number can represent 0, the additive identity.

fn can_one(&self) -> bool

Returns true if the number can represent 1, the multiplicative identity.

fn can_neg_one(&self) -> bool

Returns true if the number can represent -1, the additive inverse of the multiplicative identity.

fn is_zero(&self) -> bool

Returns true if the current value is 0. the additive identity.

fn is_one(&self) -> bool

Returns true if the current value is 1, the multiplicative identity.

fn is_neg_one(&self) -> bool

Returns true if the current value is -1, the additive inverse of the multiplicative identity.

impl LowerBounded for PositiveIntegers

fn new_min() -> Self

Returns a PositiveInteger8::new_min().

impl Number for PositiveIntegers

This implementation is no-op.

fn from_inner_repr(value: PositiveIntegers) -> NumeraResult<Self>

Returns value unchanged.

Errors

This function can’t fail.

unsafe fn from_inner_repr_unchecked(value: PositiveIntegers) -> Self

Available on crate feature not(safe) only.

Returns value unchanged.

Safety

This is safe

fn from_innermost_repr(value: PositiveIntegers) -> NumeraResult<Self>

Returns value unchanged.

Errors

This function can’t fail.

unsafe fn from_innermost_repr_unchecked(value: PositiveIntegers) -> Self

Available on crate feature not(safe) only.

Returns value unchanged.

Safety

This is safe

fn into_inner_repr(self) -> Self::InnerRepr

Returns self.

fn into_innermost_repr(self) -> Self::InnermostRepr

Returns self.

type InnerRepr = PositiveIntegers

The inner primitive representation of the number.

type InnermostRepr = PositiveIntegers

The innermost primitive representation of the number.

fn try_from_inner_repr(inner: impl Into<Self::InnerRepr>) -> NumeraResult<Self>

where Self: Sized,

Forms a new number from its converted given inner representation.

impl One for PositiveIntegers

fn new_one() -> Self

Returns a PositiveInteger8::new_one().

fn set_one(&mut self)

where Self: Sized,

Sets this number to 1.

impl PartialEq for PositiveIntegers

fn eq(&self, other: &PositiveIntegers) -> 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 Sign for PositiveIntegers

This implementation defers to the actual integer variant.

fn can_positive(&self) -> bool

Returns true if the type can represent positive numbers.

fn can_negative(&self) -> bool

Returns true if the type can represent negative numbers.

fn is_positive(&self) -> bool

Returns true if the value is positive (> 0).

fn is_negative(&self) -> bool

Returns true if the value is negative (< 0).

impl TryFrom<AllIntegers> for PositiveIntegers

type Error = NumeraErrors

The type returned in the event of a conversion error.

fn try_from(z: AllIntegers) -> Result<PositiveIntegers, Self::Error>

Performs the conversion.

impl TryFrom<PositiveIntegers> for PositiveInteger128

type Error = NumeraErrors

The type returned in the event of a conversion error.

fn try_from(z: PositiveIntegers) -> Result<PositiveInteger128, Self::Error>

Performs the conversion.

impl TryFrom<PositiveIntegers> for PositiveInteger16

type Error = NumeraErrors

The type returned in the event of a conversion error.

fn try_from(z: PositiveIntegers) -> Result<PositiveInteger16, Self::Error>

Performs the conversion.

impl TryFrom<PositiveIntegers> for PositiveInteger32

type Error = NumeraErrors

The type returned in the event of a conversion error.

fn try_from(z: PositiveIntegers) -> Result<PositiveInteger32, Self::Error>

Performs the conversion.

impl TryFrom<PositiveIntegers> for PositiveInteger64

type Error = NumeraErrors

The type returned in the event of a conversion error.

fn try_from(z: PositiveIntegers) -> Result<PositiveInteger64, Self::Error>

Performs the conversion.

impl TryFrom<PositiveIntegers> for PositiveInteger8

type Error = NumeraErrors

The type returned in the event of a conversion error.

fn try_from(z: PositiveIntegers) -> Result<PositiveInteger8, Self::Error>

Performs the conversion.

impl UpperBounded for PositiveIntegers

fn new_max() -> Self

Returns a PositiveInteger128::new_max().

impl Eq for PositiveIntegers

impl NonNegative for PositiveIntegers

impl NonZero for PositiveIntegers

impl Positive for PositiveIntegers

impl StructuralPartialEq for PositiveIntegers