Struct Money 

pub struct Money<C> { /* private fields */ }

An amount of money in a particular currency.

Money instances are immutable. All operations that would alter the state return a new instance with that new state, leaving the original instance unaltered.

Money instances also support Copy semantics. The amount Decimal is 128 bits, but statically-typed Currency implementations are typically unit structs, so they don’t add any more. References to a dynamic currency add the size of a pointer.

Implementations

impl<C> Money<C>

where C: Currency + Copy,

Functions specifically for owned statically-typed Currency instances.

pub fn format(&self, locale: &Locale) -> String

Formats this Money instance as a locale-aware string suitable for showing to a user. This uses the icu crate for CLDR formatting rules.

pub fn format_with_options( &self, locale: &Locale, options: FormattingOptions, ) -> String

Same as format but allows the caller to specify FormattingOptions.

impl Money<&dyn Currency>

Functions specifically for borrowed dynamically-typed currencies.

pub fn format(&self, locale: &Locale) -> String

Formats this Money instance as a locale-aware string suitable for showing to a user. This uses the icu crate for CLDR formatting rules.

pub fn format_with_options( &self, locale: &Locale, options: FormattingOptions, ) -> String

Same as format but allows the caller to specify FormattingOptions.

impl<C> Money<C>

where C: Copy,

Common functions for statically and dynamically-typed currencies.

pub fn new<N: Into<Decimal>>(amount: N, currency: C) -> Self

Constructs a new Money given a decimal amount and Currency. The currency argument can be either an owned statically-typed Currency instance, or a dynamically-typed reference to a Currency instance (i.e., &dyn Currency).

pub fn amount(&self) -> Decimal

Returns a copy of the amount as a Decimal.

pub fn is_zero(&self) -> bool

Returns true if the amount is zero.

pub fn is_positive(&self) -> bool

Returns true if the amount is positive.

pub fn is_negative(&self) -> bool

Returns true if the amount is negative.

pub fn round_to_precision( &self, decimal_places: u32, strategy: RoundingStrategy, ) -> Self

Returns a new instance rounded to the specified number of decimal places, using the specified strategy.

impl<C> Money<C>

where C: MinorUnits + Copy,

Methods that require knowing the minor_units of the currency.

pub fn from_minor_units(minor_units: i64, currency: C) -> Self

Constructs a Money from some number of minor units in the specified Currency. For example, 100 USD minor units is one USD, but 100 JPY minor units is 100 JPY.

pub fn round(&self, strategy: RoundingStrategy) -> Self

Returns a new instance rounded to the amount of minor units defined by the Currency.

pub fn to_minor_units(&self, rounding_strategy: RoundingStrategy) -> Option<i64>

Returns the amount in currency minor units, suitable for sending to a payment processor. If the amount is at a higher precision than the currency’s number of minor units, the amount will be rounded using the specified rounding strategy. If the amount can’t be safely represented as an i64, None will be returned.

impl<C> Money<C>

where C: Currency + Copy,

Functions specifically for owned statically-typed Currency instances.

pub fn currency(&self) -> C

Returns a copy of the Money’s Currency.

impl Money<&dyn Currency>

Functions specifically for borrowed dynamically-typed currencies.

pub fn currency(&self) -> &dyn Currency

Returns the reference to the dynamically-typed Currency.

Trait Implementations

impl<C> Add<Money<&dyn Currency>> for Money<C>

where C: Currency,

Supports Add for a Money instance with a statically-typed Currency and a Money instance with a dynamically-typed Currency. The output is a Result since the operation can fail if the currencies are incompatible.

type Output = Result<Money<C>, MoneyMathError>

The resulting type after applying the + operator.

fn add(self, rhs: Money<&dyn Currency>) -> Self::Output

Performs the + operation.

impl<C> Add<Money<C>> for Money<&dyn Currency>

where C: Currency,

Supports Add for a Money instance with a dynamically-typed Currency and a Money instance with a statically-typed Currency. The output is a Result since the operation can fail if the currencies are incompatible.

type Output = Result<Money<&dyn Currency>, MoneyMathError>

The resulting type after applying the + operator.

fn add(self, rhs: Money<C>) -> Self::Output

Performs the + operation.

impl Add for Money<&dyn Currency>

Supports Add for two Money instances with dynamically-typed currencies. The Output is a Result instead of a Money since the operation can fail if the currencies are incompatible.

type Output = Result<Money<&dyn Currency>, MoneyMathError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add for Money<C>

where C: Currency,

Supports Add for Money instances with a static currency.

type Output = Money<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C: Clone> Clone for Money<C>

fn clone(&self) -> Money<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for Money<C>

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

Formats the value using the given formatter.

impl Display for Money<&dyn Currency>

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

Formats the value using the given formatter.

impl<C> Display for Money<C>

where C: Currency,

Display::fmt is supposed to be infallible, so this just writes the amount followed by the currency code. For more sophisticated formatting, use the the format method available with the “formatting” crate feature.

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

Formats the value using the given formatter.

impl<N> Div<N> for Money<&dyn Currency>

where N: Into<Decimal>,

Supports Div for Money instances with a dynamic currency. The right-hand-side of the operation can be anything that can be converted into a Decimal.

type Output = Money<&dyn Currency>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, N> Div<N> for Money<C>

where C: Currency, N: Into<Decimal>,

Supports Div for Money instances with a static currency. The right-hand-side of the operation can be anything that can be converted into a Decimal.

type Output = Money<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<N> Mul<N> for Money<&dyn Currency>

where N: Into<Decimal>,

Supports Mul for Money instances with a dynamic currency. The right-hand-side of the operation can be anything that can be converted into a Decimal.

type Output = Money<&dyn Currency>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, N> Mul<N> for Money<C>

where C: Currency, N: Into<Decimal>,

Supports Mul for Money instances with a static currency. The right-hand-side of the operation can be anything that can be converted into a Decimal.

type Output = Money<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Money<&dyn Currency>

Supports Neg for Money instances with a dynamic currency.

type Output = Money<&dyn Currency>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<C> Neg for Money<C>

where C: Currency,

Supports Neg for Money instances with a static currency.

type Output = Money<C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<C> PartialEq<Money<&dyn Currency>> for Money<C>

where C: Currency + PartialEq,

Allows equality comparisons between Money instances with dynamically-typed currencies and those with statically-typed currencies. Both the amounts and the currency codes must match.

fn eq(&self, other: &Money<&dyn Currency>) -> 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<C> PartialEq<Money<C>> for Money<&dyn Currency>

where C: Currency,

Allows equality comparisons between Money instances with dynamically-typed currencies and those with statically-typed currencies. Both the amounts and currency codes must match.

fn eq(&self, other: &Money<C>) -> 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 Money<&dyn Currency>

Allows equality comparisons between Money instances with dynamically-typed currencies. Both the amounts and currency codes must match.

fn eq(&self, other: &Self) -> 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<C> PartialEq for Money<C>

where C: Currency + PartialEq,

Allows equality comparisons between Money instances with statically-typed currencies. The compiler will already ensure that C is the same for both instances, so only the amounts must match.

fn eq(&self, other: &Self) -> 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 for Money<&dyn Currency>

Allows ordering comparisons for Money instances with dynamically-typed currencies.

fn partial_cmp(&self, other: &Self) -> 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<C> PartialOrd for Money<C>

where C: Currency + PartialOrd,

Allows ordering comparisons for Money instances with the same statically-typed currency.

fn partial_cmp(&self, other: &Self) -> 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<N> Rem<N> for Money<&dyn Currency>

where N: Into<Decimal>,

Supports Rem for Money instances with a dynamic currency. The right-hand-side of the operation can be anything that can be converted into a Decimal.

type Output = Money<&dyn Currency>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, N> Rem<N> for Money<C>

where C: Currency, N: Into<Decimal>,

Supports Rem for Money instances with a static currency. The right-hand-side of the operation can be anything that can be converted into a Decimal.

type Output = Money<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl Serialize for Money<&dyn Currency>

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<C> Serialize for Money<C>

where C: Currency,

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<C> Sub<Money<&dyn Currency>> for Money<C>

where C: Currency,

Supports Sub for a Money instance with a statically-typed Currency and a Money instance with a dynamically-typed Currency. The output is a Result since the operation can fail if the currencies are incompatible.

type Output = Result<Money<C>, MoneyMathError>

The resulting type after applying the - operator.

fn sub(self, rhs: Money<&dyn Currency>) -> Self::Output

Performs the - operation.

impl<C> Sub<Money<C>> for Money<&dyn Currency>

where C: Currency,

Supports Sub for a Money instance with a dynamically-typed Currency and a Money instance with a statically-typed Currency. The output is a Result since the operation can fail if the currencies are incompatible.

type Output = Result<Money<&dyn Currency>, MoneyMathError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Money<&dyn Currency>

Supports Sub for two Money instances with dynamically-typed currencies. The Output is a Result instead of a Money since the operation can fail if the currencies are incompatible.

type Output = Result<Money<&dyn Currency>, MoneyMathError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub for Money<C>

where C: Currency,

Supports Sub for Money instances with a static currency.

type Output = Money<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C: Copy> Copy for Money<C>