Struct RawMoney 

pub struct RawMoney<C: Currency> { /* private fields */ }

Represents a monetary value without automatic rounding.

RawMoney is exactly like Money except it doesn’t automatically round amounts after each operation. It keeps full decimal precision and lets callers decide when to round.

Key Features

• Type Safety: Provides compile-time checks to ensure valid state.
• Precision: Uses 128-bit fixed-precision decimal for accurate calculations.
• No Automatic Rounding: Preserves all decimal places until explicitly rounded.
• Zero-Cost: Copy type with no heap allocations and currency metadata is zero-sized type.

Conversion

• Convert from Money using Money::into_raw
• Convert to Money using RawMoney::finish (applies rounding)

Where Rounding Happens

• BaseMoney::round: rounds using currency’s minor unit (bankers rounding). Returns RawMoney.
• BaseMoney::round_with: rounds using custom decimal points and strategy. Returns RawMoney.
• RawMoney::finish: rounds to currency’s minor unit using bankers rounding back to Money.

Examples

use moneylib::{Money, RawMoney, BaseMoney, macros::dec, iso::USD};

// Create RawMoney directly - no rounding
let raw = RawMoney::<USD>::new(dec!(100.567)).unwrap();
assert_eq!(raw.amount(), dec!(100.567));

// Convert from Money
let money = Money::<USD>::new(dec!(100.50)).unwrap();
let raw = money.into_raw();
assert_eq!(raw.amount(), dec!(100.50));

// Convert back to Money with rounding
let raw = RawMoney::<USD>::new(dec!(100.567)).unwrap();
let money = raw.finish();
assert_eq!(money.amount(), dec!(100.57));

See Also

• Money for automatically-rounded monetary values
• BaseMoney trait for core money operations and accessors
• BaseOps trait for arithmetic and comparison operations
• MoneyFormatter trait for custom formatting and rounding

Implementations

impl<C> RawMoney<C>

where C: Currency,

pub const fn from_decimal(amount: Decimal) -> Self

Creates a new RawMoney instance from Decimal without rounding.

Examples

use moneylib::{RawMoney, BaseMoney, macros::dec, iso::USD};

let raw = RawMoney::<USD>::from_decimal(dec!(123.309));
assert_eq!(raw.amount(), dec!(123.309));

pub fn from_minor(minor_amount: i128) -> Result<Self, MoneyError>

Creates a new RawMoney from minor amount i128 without rounding.

Examples

use moneylib::{RawMoney, BaseMoney, macros::dec, iso::{USD, BHD, JPY}};

// USD has 2 decimal places, so 12302 cents = $123.02
let raw = RawMoney::<USD>::from_minor(12302).unwrap();
assert_eq!(raw.amount(), dec!(123.02));

// JPY has 0 decimal places
let raw = RawMoney::<JPY>::from_minor(1000).unwrap();
assert_eq!(raw.amount(), dec!(1000));

// BHD has 3 decimal places
let raw = RawMoney::<BHD>::from_minor(12345).unwrap();
assert_eq!(raw.amount(), dec!(12.345));

pub fn finish(self) -> Money<C>

Converts this RawMoney to Money, applying rounding.

Rounds the amount to the currency’s minor unit precision using the bankers rounding rule, then returns a Money instance.

Examples

use moneylib::{RawMoney, BaseMoney, macros::dec, iso::{USD, JPY, BHD}};

let raw = RawMoney::<USD>::new(dec!(100.567)).unwrap();
let money = raw.finish();
assert_eq!(money.amount(), dec!(100.57));

let raw_jpy = RawMoney::<JPY>::new(dec!(100.567)).unwrap();
let money = raw_jpy.finish();
assert_eq!(money.amount(), dec!(101));

let raw_bhd = RawMoney::<BHD>::new(dec!(100.9999)).unwrap();
let money = raw_bhd.finish();
assert_eq!(money.amount(), dec!(101.000));

pub fn from_code_comma_thousands(s: &str) -> Result<Self, MoneyError>

Parses a string in the format "CCC amount" (comma thousands separator and dot decimal separator).

The format is "CCC amount" where CCC is a currency code (1-15 letters).

For dot thousands separator format (e.g., "EUR 1.234,56"), use RawMoney::from_code_dot_thousands instead.

Examples

use moneylib::{RawMoney, BaseMoney, macros::dec, iso::USD};
use std::str::FromStr;

let raw = RawMoney::<USD>::from_code_comma_thousands("USD 1,234.56789").unwrap();
assert_eq!(raw.amount(), dec!(1234.56789));
assert_eq!(raw.code(), "USD");

assert!(RawMoney::<USD>::from_code_comma_thousands("EUR 100.00").is_err());

pub fn from_code_dot_thousands(s: &str) -> Result<Self, MoneyError>

Creates a new RawMoney from a string with dot as the thousands separator and comma as the decimal separator (e.g., "EUR 1.234,56").

The format is "CCC amount" where CCC is a currency code (1-15 letters) and

Examples

use moneylib::{RawMoney, BaseMoney, iso::{EUR, USD}};

let raw = RawMoney::<EUR>::from_code_dot_thousands("EUR 1.234,56").unwrap();
assert_eq!(raw.code(), "EUR");

assert!(RawMoney::<USD>::from_code_dot_thousands("EUR 1.234,56").is_err());

pub fn from_symbol_comma_thousands(s: &str) -> Result<Self, MoneyError>

Parse from string with symbol, comma-separated thousands, dot-separated decimal, no rounding Example: $1,234.2249 into USD 1234.2249

pub fn from_symbol_dot_thousands(s: &str) -> Result<Self, MoneyError>

Parse from string with symbol, dot-separated thousands, comma-separated decimal, no rounding Example: $1.234,2249 into USD 1234.2249

pub fn from_code_locale_separator(s: &str) -> Result<Self, MoneyError>

Parse from string with code, locale thousands and decimal separators.

Code is space separated with amount.

Currencies locale separators are from here: https://docs.rs/currencylib

Example

use moneylib::{RawMoney, raw, iso::CHF, dec, BaseMoney};

let money = RawMoney::<CHF>::from_code_locale_separator("CHF 1'123'456.2223").unwrap();
assert_eq!(money.code(), "CHF");
assert_eq!(money.symbol(), "₣");
assert_eq!(money.amount(), dec!(1123456.2223));
assert_eq!(money, raw!(CHF, 1123456.2223));

pub fn from_symbol_locale_separator(s: &str) -> Result<Self, MoneyError>

Parse from string with symbol, locale thousands and decimal separators.

There’s no space between symbol and amount.

Currencies locale separators are from here: https://docs.rs/currencylib

Example

use moneylib::{RawMoney, raw, iso::CHF, dec, BaseMoney};

let money = RawMoney::<CHF>::from_symbol_locale_separator("₣1'123'456.2223").unwrap();
assert_eq!(money.code(), "CHF");
assert_eq!(money.symbol(), "₣");
assert_eq!(money.amount(), dec!(1123456.2223));
assert_eq!(money, raw!(CHF, 1123456.2223));

Trait Implementations

impl<C> Add<Decimal> for RawMoney<C>

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<RawMoney<C>> for Decimal

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add for RawMoney<C>

where C: Currency,

RawMoney + RawMoney = RawMoney (no auto-rounding)

type Output = RawMoney<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> AddAssign for RawMoney<C>

where C: Currency,

RawMoney += RawMoney (no auto-rounding)

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<C> BaseMoney<C> for RawMoney<C>

where C: Currency,

fn round(self) -> Self

Rounds explicitly to the currency’s minor unit using bankers rounding.

Unlike Money, this must be called explicitly. Returns RawMoney.

Examples

use moneylib::{RawMoney, BaseMoney, macros::dec, iso::USD};

let raw = RawMoney::<USD>::from_decimal(dec!(100.567));
let rounded = raw.round();
assert_eq!(rounded.amount(), dec!(100.57));

// round() returns RawMoney, not Money
let rounded_again = rounded.round();
assert_eq!(rounded_again.amount(), dec!(100.57));

fn minor_amount(&self) -> Option<i128>

Returns the money amount in its smallest unit, rounding as needed.

Since minor amounts must be integers, this rounds the raw amount to the currency’s minor unit precision before computing the minor amount.

Examples

use moneylib::{RawMoney, BaseMoney, macros::dec, iso::USD};

let raw = RawMoney::<USD>::from_decimal(dec!(123.45));
assert_eq!(raw.minor_amount().unwrap(), 12345_i128);

// Extra precision is rounded before computing minor amount
let raw = RawMoney::<USD>::from_decimal(dec!(123.238533));
assert_eq!(raw.minor_amount().unwrap(), 12324_i128);

fn new(amount: impl DecimalNumber) -> Result<Self, MoneyError>

Creates a new Money instance with amount of Decimal, f64, i32, i64, i128.

fn amount(&self) -> Decimal

Returns the decimal amount of this money value.

fn round_with(self, decimal_points: u32, strategy: RoundingStrategy) -> Self

Rounds the money amount to a specified number of decimal places using the given strategy.

fn truncate(&self) -> Self

Truncates the money amount removing the fraction.

fn truncate_with(&self, scale: u32) -> Self

Truncates the money amount to certain scale.

fn name(&self) -> &str

Returns the full name of the currency.

fn symbol(&self) -> &str

Returns the currency symbol.

fn code(&self) -> &str

Returns the ISO 4217 currency code.

fn numeric_code(&self) -> i32

Returns the ISO 4217 numeric code for the currency.

fn minor_unit(&self) -> u16

Returns the number of decimal places used by the currency’s minor unit.

fn thousand_separator(&self) -> &str

Returns the thousands separator used by the currency.

fn decimal_separator(&self) -> &str

Returns the decimal separator used by the currency.

fn is_zero(&self) -> bool

Returns true if the amount is zero.

fn is_positive(&self) -> bool

Returns true if the amount is positive.

fn is_negative(&self) -> bool

Returns true if the amount is negative.

fn mantissa(&self) -> i128

Returns the mantissa(significand digits) of money.

fn fraction(&self) -> Decimal

Returns the fractional part of the money.

fn scale(&self) -> u32

Returns the the scale.

fn format_code(&self) -> String

Formats money with currency code along with thousands and decimal separators.

fn format_symbol(&self) -> String

Formats money with currency symbol along with thousands and decimal separators.

fn format_code_minor(&self) -> String

Formats money with currency code in the smallest unit along with thousands separators.

fn format_symbol_minor(&self) -> String

Formats money with currency symbol in the smallest unit along with thousands separators.

fn display(&self) -> String

Returns the default display format for money (same as format_code).

impl<C> BaseOps<C> for RawMoney<C>

where C: Currency,

fn abs(&self) -> Self

Returns the absolute value of the money amount.

fn checked_add<RHS>(&self, rhs: RHS) -> Option<Self>

where RHS: Amount<C>,

Adds another money value to this one.

fn checked_sub<RHS>(&self, rhs: RHS) -> Option<Self>

where RHS: Amount<C>,

Subtracts another money value from this one.

fn checked_mul<RHS>(&self, rhs: RHS) -> Option<Self>

where RHS: DecimalNumber,

Multiplies this money value by another value.

fn checked_div<RHS>(&self, rhs: RHS) -> Option<Self>

where RHS: DecimalNumber,

Divides this money value by another value.

fn checked_rem<RHS>(&self, rhs: RHS) -> Option<Self>

where RHS: DecimalNumber,

Get remainder of self % rhs.

fn is_approx<M, T>(&self, m: M, tolerance: T) -> bool

where M: BaseMoney<C> + BaseOps<C> + Amount<C>, T: DecimalNumber,

Compare 2 moneys within tolerance(inclusive).

fn split<P, R>(&self, p: P) -> Option<R>

where R: Split<Self, C, P>,

Split money without losing a single penny.

impl<C: Currency> Clone for RawMoney<C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for RawMoney<C>

where C: Currency,

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

Formats the value using the given formatter.

impl<C: Currency> Default for RawMoney<C>

fn default() -> Self

Returns money with zero amount.

impl<'de, C: Currency> Deserialize<'de> for RawMoney<C>

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

Deserialize this value from the given Serde deserializer.

impl<C> Display for RawMoney<C>

where C: Currency,

Formats RawMoney using the currency code and full decimal precision.

Examples

use moneylib::{RawMoney, macros::dec, iso::USD};

let raw = RawMoney::<USD>::from_decimal(dec!(1234.567));
assert_eq!(format!("{}", raw), "USD 1,234.567");

let raw = RawMoney::<USD>::from_decimal(dec!(-1234.56));
assert_eq!(format!("{}", raw), "USD -1,234.56");

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

Formats the value using the given formatter.

impl<C> Div<Decimal> for RawMoney<C>

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<RawMoney<C>> for Decimal

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the / operator.

fn div(self, rhs: RawMoney<C>) -> Self::Output

Performs the / operation.

impl<C> Div for RawMoney<C>

where C: Currency,

RawMoney / RawMoney = RawMoney (no auto-rounding)

type Output = RawMoney<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> DivAssign for RawMoney<C>

where C: Currency,

RawMoney /= RawMoney (no auto-rounding)

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<C> FromStr for RawMoney<C>

where C: Currency,

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

Parse money from string number.

Examples

use moneylib::{BaseMoney, RawMoney, iso::USD, raw, dec};
use std::str::FromStr;

let money = RawMoney::<USD>::from_str("12334.4439").unwrap();
assert_eq!(money, raw!(USD, 12334.4439));
assert_eq!(money.amount(), dec!(12334.4439));

type Err = MoneyError

The associated error which can be returned from parsing.

impl<C> MoneyFormatter<C> for RawMoney<C>

where C: Currency,

fn format(&self, format_str: &str) -> String

Format money according to the provided format string format_str.

fn format_with_separator( &self, format_str: &str, thousand_separator: &str, decimal_separator: &str, ) -> String

Format money according to the provided format string format_str.

fn format_locale_amount( &self, locale_str: &str, format_str: &str, ) -> Result<String, MoneyError>

Format money’s amount using locale standard with format_str format.

impl<C> Mul<Decimal> for RawMoney<C>

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<RawMoney<C>> for Decimal

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the * operator.

fn mul(self, rhs: RawMoney<C>) -> Self::Output

Performs the * operation.

impl<C> Mul for RawMoney<C>

where C: Currency,

RawMoney * RawMoney = RawMoney (no auto-rounding)

type Output = RawMoney<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> MulAssign for RawMoney<C>

where C: Currency,

RawMoney *= RawMoney (no auto-rounding)

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<C> Neg for RawMoney<C>

where C: Currency,

Negation: -RawMoney = RawMoney

type Output = RawMoney<C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<C: Currency + Copy + 'static + Send + Sync> ObjMoney for RawMoney<C>

fn amount(&self) -> Decimal

Returns the decimal amount of this money value.

fn code(&self) -> &str

Returns the ISO 4217 currency code (e.g. "USD").

fn symbol(&self) -> &str

Returns the currency symbol (e.g. "$").

fn name(&self) -> &str

Returns the full name of the currency (e.g. "United States dollar").

fn minor_unit(&self) -> u16

Returns the number of decimal places in the currency’s minor unit (e.g. 2 for USD).

fn thousand_separator(&self) -> &str

Returns the thousands separator used by the currency’s locale (e.g. "," for USD).

fn decimal_separator(&self) -> &str

Returns the decimal separator used by the currency’s locale (e.g. "." for USD).

fn minor_unit_symbol(&self) -> &str

Returns the minor-unit symbol (e.g. "¢" for USD, "minor" when none is defined).

fn minor_amount(&self) -> Option<i128>

Returns the money amount in its smallest unit (e.g. cents for USD, pence for GBP).

fn as_any(&self) -> &dyn Any

Get object money as Any

fn convert( &self, to_code: &str, rate: &dyn ObjRate, ) -> Result<Box<dyn ObjMoney>, MoneyError>

Convert ObjMoney to to_code with rate

fn is_zero(&self) -> bool

Returns true if the amount is zero.

fn is_positive(&self) -> bool

Returns true if the amount is positive.

fn is_negative(&self) -> bool

Returns true if the amount is negative.

fn scale(&self) -> u32

Returns the scale (number of decimal places) of the stored amount.

fn fraction(&self) -> Decimal

Returns the fractional part of the amount.

fn mantissa(&self) -> i128

Returns the mantissa (significand digits) of the amount.

fn format_code(&self) -> String

Formats money with currency code and locale separators (e.g. "USD 1,234.56").

fn format_symbol(&self) -> String

Formats money with currency symbol and locale separators (e.g. "$1,234.56").

fn format_code_minor(&self) -> String

Formats money with currency code in the smallest unit (e.g. "USD 123,456 ¢").

fn format_symbol_minor(&self) -> String

Formats money with currency symbol in the smallest unit (e.g. "$123,456 ¢").

impl<C> Ord for RawMoney<C>

where C: Currency + PartialEq + Eq,

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<C: PartialEq + Currency> PartialEq for RawMoney<C>

fn eq(&self, other: &RawMoney<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<C> PartialOrd for RawMoney<C>

where C: Currency + PartialEq + Eq,

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<From: Currency, To: Currency> Rate<From, To> for RawMoney<To>

fn get_rate(&self) -> Option<Decimal>

Get T’s rate relative to C.

impl<C> Rem<Decimal> for RawMoney<C>

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C: Currency> Serialize for RawMoney<C>

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

Serialize this value into the given Serde serializer.

impl<C> Sub<Decimal> for RawMoney<C>

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<RawMoney<C>> for Decimal

where C: Currency,

type Output = RawMoney<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub for RawMoney<C>

where C: Currency,

RawMoney - RawMoney = RawMoney (no auto-rounding)

type Output = RawMoney<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> SubAssign for RawMoney<C>

where C: Currency,

RawMoney -= RawMoney (no auto-rounding)

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<'a, C: Currency> Sum<&'a RawMoney<C>> for RawMoney<C>

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

Sum all moneys(borrowed)

WARN: PANIC!!! if overflowed.

impl<C: Currency> Sum for RawMoney<C>

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

Sum all moneys

WARN: PANIC! if overflowed.

impl<C: Currency + Copy + 'static + Send + Sync> TryFrom<&dyn ObjMoney> for RawMoney<C>

Converts a reference to an ObjMoney trait object into RawMoney<C>.

The conversion succeeds when the currency code of the trait object matches C::CODE. The amount is stored without any rounding, preserving full decimal precision, exactly as RawMoney::from_decimal does.

Errors

Returns MoneyError::CurrencyMismatchError when the currency codes do not match.

Examples

use moneylib::{RawMoney, ObjMoney, BaseMoney, MoneyError, macros::dec, iso::{USD, EUR}};

let obj: Box<dyn ObjMoney> = Box::new(RawMoney::<USD>::new(dec!(100.567)).unwrap());

// Successful conversion
let raw = RawMoney::<USD>::try_from(obj.as_ref()).unwrap();
assert_eq!(BaseMoney::amount(&raw), dec!(100.567));
assert_eq!(BaseMoney::code(&raw), "USD");

// Currency mismatch returns an error
assert!(RawMoney::<EUR>::try_from(obj.as_ref()).is_err());

type Error = MoneyError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<C: Copy + Currency> Copy for RawMoney<C>

impl<C: Eq + Currency> Eq for RawMoney<C>

impl<C> MoneyOps<C> for RawMoney<C>

where C: Currency,

impl<C: Currency> StructuralPartialEq for RawMoney<C>