Struct Positive 

pub struct Positive(pub Decimal);

A wrapper type that represents a guaranteed positive decimal value.

This type encapsulates a Decimal value and ensures through its API that the contained value is always positive (greater than or equal to zero).

Tuple Fields

0: Decimal

Implementations

impl Positive

pub const ZERO: Positive = crate::constants::ZERO

A zero value represented as a Positive value.

pub const ONE: Positive = crate::constants::ONE

A value of one represented as a Positive value.

pub const TWO: Positive = crate::constants::TWO

A value of two represented as a Positive value.

pub const THREE: Positive = crate::constants::THREE

A value of three represented as a Positive value.

pub const FOUR: Positive = crate::constants::FOUR

A value of four represented as a Positive value.

pub const FIVE: Positive = crate::constants::FIVE

A value of five represented as a Positive value.

pub const SIX: Positive = crate::constants::SIX

A value of six represented as a Positive value.

pub const SEVEN: Positive = crate::constants::SEVEN

A value of seven represented as a Positive value.

pub const EIGHT: Positive = crate::constants::EIGHT

A value of eight represented as a Positive value.

pub const NINE: Positive = crate::constants::NINE

A value of nine represented as a Positive value.

pub const TEN: Positive = crate::constants::TEN

A value of ten represented as a Positive value.

pub const FIFTEEN: Positive = crate::constants::FIFTEEN

A value of fifteen represented as a Positive value.

pub const TWENTY: Positive = crate::constants::TWENTY

A value of twenty represented as a Positive value.

pub const TWENTY_FIVE: Positive = crate::constants::TWENTY_FIVE

A value of twenty-five represented as a Positive value.

pub const THIRTY: Positive = crate::constants::THIRTY

A value of thirty represented as a Positive value.

pub const THIRTY_FIVE: Positive = crate::constants::THIRTY_FIVE

A value of thirty-five represented as a Positive value.

pub const FORTY: Positive = crate::constants::FORTY

A value of forty represented as a Positive value.

pub const FORTY_FIVE: Positive = crate::constants::FORTY_FIVE

A value of forty-five represented as a Positive value.

pub const FIFTY: Positive = crate::constants::FIFTY

A value of fifty represented as a Positive value.

pub const FIFTY_FIVE: Positive = crate::constants::FIFTY_FIVE

A value of fifty-five represented as a Positive value.

pub const SIXTY: Positive = crate::constants::SIXTY

A value of sixty represented as a Positive value.

pub const SIXTY_FIVE: Positive = crate::constants::SIXTY_FIVE

A value of sixty-five represented as a Positive value.

pub const SEVENTY: Positive = crate::constants::SEVENTY

A value of seventy represented as a Positive value.

pub const SEVENTY_FIVE: Positive = crate::constants::SEVENTY_FIVE

A value of seventy-five represented as a Positive value.

pub const EIGHTY: Positive = crate::constants::EIGHTY

A value of eighty represented as a Positive value.

pub const EIGHTY_FIVE: Positive = crate::constants::EIGHTY_FIVE

A value of eighty-five represented as a Positive value.

pub const NINETY: Positive = crate::constants::NINETY

A value of ninety represented as a Positive value.

pub const NINETY_FIVE: Positive = crate::constants::NINETY_FIVE

A value of ninety-five represented as a Positive value.

pub const HUNDRED: Positive = crate::constants::HUNDRED

A value of one hundred represented as a Positive value.

pub const TWO_HUNDRED: Positive = crate::constants::TWO_HUNDRED

A value of two hundred represented as a Positive value.

pub const THREE_HUNDRED: Positive = crate::constants::THREE_HUNDRED

A value of three hundred represented as a Positive value.

pub const FOUR_HUNDRED: Positive = crate::constants::FOUR_HUNDRED

A value of four hundred represented as a Positive value.

pub const FIVE_HUNDRED: Positive = crate::constants::FIVE_HUNDRED

A value of five hundred represented as a Positive value.

pub const SIX_HUNDRED: Positive = crate::constants::SIX_HUNDRED

A value of six hundred represented as a Positive value.

pub const SEVEN_HUNDRED: Positive = crate::constants::SEVEN_HUNDRED

A value of seven hundred represented as a Positive value.

pub const EIGHT_HUNDRED: Positive = crate::constants::EIGHT_HUNDRED

A value of eight hundred represented as a Positive value.

pub const NINE_HUNDRED: Positive = crate::constants::NINE_HUNDRED

A value of nine hundred represented as a Positive value.

pub const THOUSAND: Positive = crate::constants::THOUSAND

A value of one thousand represented as a Positive value.

pub const TWO_THOUSAND: Positive = crate::constants::TWO_THOUSAND

A value of two thousand represented as a Positive value.

pub const THREE_THOUSAND: Positive = crate::constants::THREE_THOUSAND

A value of three thousand represented as a Positive value.

pub const FOUR_THOUSAND: Positive = crate::constants::FOUR_THOUSAND

A value of four thousand represented as a Positive value.

pub const FIVE_THOUSAND: Positive = crate::constants::FIVE_THOUSAND

A value of five thousand represented as a Positive value.

pub const SIX_THOUSAND: Positive = crate::constants::SIX_THOUSAND

A value of six thousand represented as a Positive value.

pub const SEVEN_THOUSAND: Positive = crate::constants::SEVEN_THOUSAND

A value of seven thousand represented as a Positive value.

pub const EIGHT_THOUSAND: Positive = crate::constants::EIGHT_THOUSAND

A value of eight thousand represented as a Positive value.

pub const NINE_THOUSAND: Positive = crate::constants::NINE_THOUSAND

A value of nine thousand represented as a Positive value.

pub const TEN_THOUSAND: Positive = crate::constants::TEN_THOUSAND

A value of ten thousand represented as a Positive value.

pub const PI: Positive = crate::constants::PI

The mathematical constant π (pi) represented as a Positive value.

pub const E: Positive = crate::constants::E

The mathematical constant e (Euler’s number) represented as a Positive value.

pub const INFINITY: Positive = crate::constants::INFINITY

Represents the maximum positive value possible (effectively infinity).

pub fn new(value: f64) -> Result<Self, PositiveError>

Creates a new Positive value from a 64-bit floating-point number.

pub fn new_decimal(value: Decimal) -> Result<Self, PositiveError>

Creates a new Positive value directly from a Decimal.

pub fn value(&self) -> Decimal

Returns the inner Decimal value.

pub fn to_dec(&self) -> Decimal

Returns the inner Decimal value (alias for value()).

pub fn to_dec_ref(&self) -> &Decimal

Returns the inner Decimal ref.

pub fn to_f64(&self) -> f64

Converts the value to a 64-bit floating-point number.

Panics

This method will panic if the conversion fails. Use to_f64_checked() or to_f64_lossy() for non-panicking alternatives.

pub fn to_f64_checked(&self) -> Option<f64>

Converts the value to f64, returning None if conversion fails.

pub fn to_f64_lossy(&self) -> f64

Converts the value to f64 with lossy conversion (returns 0.0 on failure).

pub fn to_i64(&self) -> i64

Converts the value to a 64-bit signed integer.

Panics

This method will panic if the conversion fails. Use to_i64_checked() for a non-panicking alternative.

pub fn to_i64_checked(&self) -> Option<i64>

Converts the value to i64, returning None if conversion fails.

pub fn to_u64(&self) -> u64

Converts the inner value to a u64.

Panics

This method will panic if the conversion fails. Use to_u64_checked() for a non-panicking alternative.

pub fn to_u64_checked(&self) -> Option<u64>

Converts the value to u64, returning None if conversion fails.

pub fn to_usize(&self) -> usize

Converts the value to a usize.

Panics

This method will panic if the conversion fails. Use to_usize_checked() for a non-panicking alternative.

pub fn to_usize_checked(&self) -> Option<usize>

Converts the value to usize, returning None if conversion fails.

pub fn max(self, other: Positive) -> Positive

Returns the maximum of two Positive values.

pub fn min(self, other: Positive) -> Positive

Returns the minimum of two Positive values.

pub fn floor(&self) -> Positive

Rounds the value down to the nearest integer.

pub fn powi(&self, n: i64) -> Positive

Raises this value to an integer power.

pub fn pow(&self, n: Positive) -> Positive

Computes the result of raising the current value to the power of the given exponent.

pub fn powu(&self, n: u64) -> Positive

Raises the current value to the power of n using unsigned integer exponentiation.

pub fn powd(&self, p0: Decimal) -> Positive

Raises this value to a decimal power.

pub fn round(&self) -> Positive

Rounds the value to the nearest integer.

pub fn round_to_nice_number(&self) -> Positive

Rounds the current value to a “nice” number, based on its magnitude.

pub fn sqrt(&self) -> Positive

Calculates the square root of the value.

Panics

This method will panic if the square root calculation fails. Use sqrt_checked() for a non-panicking alternative.

pub fn sqrt_checked(&self) -> Result<Positive, PositiveError>

Calculates the square root, returning an error if it fails.

pub fn ln(&self) -> Positive

Calculates the natural logarithm of the value.

pub fn round_to(&self, decimal_places: u32) -> Positive

Rounds the value to a specified number of decimal places.

pub fn format_fixed_places(&self, decimal_places: u32) -> String

Formats the value with a fixed number of decimal places.

pub fn exp(&self) -> Positive

Calculates the exponential function e^x for this value.

pub fn clamp(&self, min: Positive, max: Positive) -> Positive

Clamps the value between a minimum and maximum.

pub fn is_zero(&self) -> bool

Checks if the value is exactly zero.

pub fn ceiling(&self) -> Positive

Returns the smallest integer greater than or equal to the value.

pub fn log10(&self) -> Positive

Computes the base-10 logarithm of the value.

pub fn sub_or_zero(&self, other: &Decimal) -> Positive

Subtracts a decimal value, returning zero if the result would be negative.

pub fn sub_or_none(&self, other: &Decimal) -> Option<Positive>

Subtracts a decimal value, returning None if the result would be negative.

pub fn checked_sub(&self, rhs: &Self) -> Result<Self, PositiveError>

Checked subtraction that returns Result instead of panicking.

pub fn saturating_sub(&self, rhs: &Self) -> Self

Saturating subtraction that returns ZERO instead of negative.

pub fn checked_div(&self, rhs: &Self) -> Result<Self, PositiveError>

Checked division that returns Result instead of panicking.

pub fn is_multiple(&self, other: f64) -> bool

Checks whether the value is a multiple of another f64 value.

pub fn is_multiple_of(&self, other: &Positive) -> bool

Checks whether the value is a multiple of another Positive value.

pub const unsafe fn new_unchecked(value: Decimal) -> Self

Creates a new Positive value without checking if the value is non-negative.

Safety

The caller must ensure that value >= 0. Using this with a negative value will violate the invariant of the Positive type and may cause undefined behavior in code that relies on the positivity guarantee.

Example

use positive::Positive;
use rust_decimal_macros::dec;

// SAFETY: We know 5.0 is positive
let value = unsafe { Positive::new_unchecked(dec!(5.0)) };
assert_eq!(value.to_f64(), 5.0);

Trait Implementations

impl AbsDiffEq for Positive

type Epsilon = Decimal

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl Add<&Decimal> for Positive

type Output = Positive

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Positive> for Decimal

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, rhs: &Positive) -> Decimal

Performs the + operation.

impl Add<Decimal> for Positive

type Output = Positive

The resulting type after applying the + operator.

fn add(self, rhs: Decimal) -> Positive

Performs the + operation.

impl Add<Positive> for Decimal

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, rhs: Positive) -> Decimal

Performs the + operation.

impl Add<Positive> for f64

type Output = f64

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f64> for Positive

type Output = Positive

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Positive

type Output = Positive

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Positive> for Decimal

fn add_assign(&mut self, rhs: &Positive)

Performs the += operation.

impl AddAssign<Decimal> for Positive

fn add_assign(&mut self, rhs: Decimal)

Performs the += operation.

impl AddAssign<Positive> for Decimal

fn add_assign(&mut self, rhs: Positive)

Performs the += operation.

impl AddAssign for Positive

fn add_assign(&mut self, other: Positive)

Performs the += operation.

impl Clone for Positive

fn clone(&self) -> Positive

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Positive

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

Formats the value using the given formatter.

impl Default for Positive

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Positive

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Positive

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

Formats the value using the given formatter.

impl Div<&Decimal> for Positive

type Output = Positive

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Decimal> for Positive

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: Decimal) -> Positive

Performs the / operation.

impl Div<Positive> for Decimal

type Output = Decimal

The resulting type after applying the / operator.

fn div(self, rhs: Positive) -> Decimal

Performs the / operation.

impl Div<Positive> for f64

type Output = f64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for &Positive

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Positive

Performs the / operation.

impl Div<f64> for Positive

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Positive

Performs the / operation.

impl Div for &Positive

type Output = Positive

The resulting type after applying the / operator.

fn div(self, other: &Positive) -> Self::Output

Performs the / operation.

impl Div for Positive

type Output = Positive

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<&Positive> for Decimal

fn from(pos: &Positive) -> Self

Converts to this type from the input type.

impl From<&Positive> for Positive

fn from(value: &Positive) -> Self

Converts to this type from the input type.

impl From<&Positive> for f64

fn from(value: &Positive) -> Self

Converts to this type from the input type.

impl From<Positive> for Decimal

fn from(value: Positive) -> Self

Converts to this type from the input type.

impl From<Positive> for f64

fn from(value: Positive) -> Self

Converts to this type from the input type.

impl From<Positive> for u64

fn from(pos_u64: Positive) -> Self

Converts to this type from the input type.

impl From<Positive> for usize

fn from(value: Positive) -> Self

Converts to this type from the input type.

impl FromStr for Positive

type Err = String

The associated error which can be returned from parsing.

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

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

impl Hash for Positive

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 Mul<Decimal> for Positive

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: Decimal) -> Positive

Performs the * operation.

impl Mul<Positive> for Decimal

type Output = Decimal

The resulting type after applying the * operator.

fn mul(self, rhs: Positive) -> Decimal

Performs the * operation.

impl Mul<Positive> for f64

type Output = f64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for Positive

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Positive

Performs the * operation.

impl Mul for Positive

type Output = Positive

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&Positive> for Decimal

fn mul_assign(&mut self, rhs: &Positive)

Performs the *= operation.

impl MulAssign<Decimal> for Positive

fn mul_assign(&mut self, rhs: Decimal)

Performs the *= operation.

impl MulAssign<Positive> for Decimal

fn mul_assign(&mut self, rhs: Positive)

Performs the *= operation.

impl Neg for Positive

type Output = Positive

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for Positive

fn cmp(&self, other: &Self) -> 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 PartialEq<&Positive> for Positive

fn eq(&self, other: &&Positive) -> 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 PartialEq<&Positive> for f64

fn eq(&self, other: &&Positive) -> 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 PartialEq<Decimal> for Positive

fn eq(&self, other: &Decimal) -> 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 PartialEq<Positive> for Decimal

fn eq(&self, other: &Positive) -> 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 PartialEq<Positive> for f64

fn eq(&self, other: &Positive) -> 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 PartialEq<f64> for &Positive

fn eq(&self, other: &f64) -> 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 PartialEq<f64> for Positive

fn eq(&self, other: &f64) -> 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 PartialEq for Positive

fn eq(&self, other: &Positive) -> 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 PartialOrd<&Positive> for f64

fn partial_cmp(&self, other: &&Positive) -> 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 PartialOrd<Decimal> for Positive

fn partial_cmp(&self, other: &Decimal) -> 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 PartialOrd<Positive> for f64

fn partial_cmp(&self, other: &Positive) -> 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 PartialOrd<f64> for &Positive

fn partial_cmp(&self, other: &f64) -> 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 PartialOrd<f64> for Positive

fn partial_cmp(&self, other: &f64) -> 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 PartialOrd for Positive

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

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

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

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

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

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

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

Tests less than (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.

impl RelativeEq for Positive

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl Serialize for Positive

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<&Decimal> for Positive

type Output = Positive

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Positive> for Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, rhs: &Positive) -> Decimal

Performs the - operation.

impl Sub<Decimal> for Positive

type Output = Positive

The resulting type after applying the - operator.

fn sub(self, rhs: Decimal) -> Positive

Performs the - operation.

impl Sub<Positive> for Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, rhs: Positive) -> Decimal

Performs the - operation.

impl Sub<Positive> for f64

type Output = f64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f64> for Positive

type Output = Positive

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Positive

type Output = Positive

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sum<&'a Positive> for Positive

fn sum<I: Iterator<Item = &'a Positive>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum for Positive

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl TryFrom<&Decimal> for Positive

fn try_from(value: &Decimal) -> Result<Self, Self::Error>

Attempts to convert a &Decimal to a Positive value.

Errors

Returns PositiveError if the value is negative.

type Error = PositiveError

The type returned in the event of a conversion error.

impl TryFrom<Decimal> for Positive

fn try_from(value: Decimal) -> Result<Self, Self::Error>

Attempts to convert a Decimal to a Positive value.

Errors

Returns PositiveError if the value is negative.

type Error = PositiveError

The type returned in the event of a conversion error.

impl TryFrom<f64> for Positive

fn try_from(value: f64) -> Result<Self, Self::Error>

Attempts to convert an f64 to a Positive value.

Errors

Returns PositiveError if the value is negative, NaN, or cannot be converted to Decimal.

type Error = PositiveError

The type returned in the event of a conversion error.

impl TryFrom<i64> for Positive

fn try_from(value: i64) -> Result<Self, Self::Error>

Attempts to convert an i64 to a Positive value.

Errors

Returns PositiveError if the value is negative.

type Error = PositiveError

The type returned in the event of a conversion error.

impl TryFrom<u64> for Positive

fn try_from(value: u64) -> Result<Self, Self::Error>

Attempts to convert a u64 to a Positive value.

Errors

This conversion is infallible for u64 since all values are non-negative.

type Error = PositiveError

The type returned in the event of a conversion error.

impl TryFrom<usize> for Positive

fn try_from(value: usize) -> Result<Self, Self::Error>

Attempts to convert a usize to a Positive value.

Errors

Returns PositiveError if the value cannot be converted to Decimal.

type Error = PositiveError

The type returned in the event of a conversion error.

impl Copy for Positive

impl Eq for Positive

impl StructuralPartialEq for Positive