#currency #money #amount #macro #conversion #decimal #arithmetic


Companion library to oxydized-gains providing convenience macros

2 unstable releases

0.2.0 Mar 3, 2024
0.1.0 Mar 3, 2024

#115 in Finance

MIT license


Oxydized Money 💵 ↔ 💶

Build Test Clippy Doc

Crates.io Docs.rs Crates.io Crates.io

This crate aims at providing data types to manipulate amounts of money in specific currencies, convert amounts between currencies and make sure that any computation is performed on amounts of the same currency.


This crate was introduced because all the existing known alternatives have some signigicant drawbacks:

  • using native floating point type like f32 or f64 suffer from their lack of precision.
  • using rust_decimal::Decimal solves this issue but does not prevent from adding amounts in different currency.
  • using rusty_money::Money, although slightly better, does not really solve the conversion issue because performing arithmetic operations on amounts of different currencies panics.

Rust being dedicated to proper error handling, all these options feel like compromises. This crate aims to improve this by by providing three distinct data types:

  • Amount for storing amounts in a given currency.
  • CurrencyError for representing any errors (currency mismatch, ...) during arithmetic operations on Amounts.
  • AmountResult for storing the result of arithmetic operations (either an Amount or CurrencyError).

Arithmetic operations are defined in such a way that these three types inte-roperate almost seemlessly. However, when performing an operation, the type of output always reflect whether an error could have occured. Operation that cannot fail will output Amounts and operations that can fail will outout AmountResults. Before getting at the underlying Amount, AmountResults need to be properly checked for errors.

No more 🦶-guns


use oxydized_money_macros::{eur, usd, dec};
use oxydized_money::{

// Amount(USD)
let capital = usd!(10_000);

// Decinal
let exchange_rate = dec!(0.928);

// Amount(EUR)
let converted = capital.converted_to(EUR, exchange_rate);

// Amount(EUR)
let fees = eur!(15.2);

// Amount(EUR) + Amount(EUR) => AmountResult(EUR)
let subtotal = converted + fees;

// Amount(EUR) * Decimal => Amount(EUR)
let extras = eur!(50) * dec!(2);

// AmountResult(EUR) + Amount(EUR) => AmountResult(EUR)
let total = subtotal + extras;

// Comparing AmountResult with Amounts
assert_eq!(total, eur!(9_395.200));
// AmountResult(EUR) + Amount(USD) => AmountResult(Mismatch(EUR,USD))
let oops = total + usd!(20);

// Comparing AmountResult with CurrencyError
assert_eq!(oops, CurrencyError::Mismatch(EUR,USD));

// AmountResult(Mismatch(EUR,USD)) + Amount(USD) => AmountResult(Mismatch(EUR,USD))
let oh_my = oops + usd!(200);
assert_eq!(oh_my, CurrencyError::Mismatch(EUR,USD));

// "Everything, everywhere, all at once."
    usd!(10_000).converted_to(EUR, dec!(0.928)) + eur!(15.2) + eur!(50)*dec!(2),

Supported Operations

Binary Operations


Left Operand Operator Right Operand Output
Amount * Decimal Amount
Amount / Decimal AmountResult
Amount {+,-} Amount AmountResult
Amount {+,-} AmountResult AmountResult
Amount {==,!=} Amount bool
Amount {==,!=} AmountResult bool
Amount {<,>,>=,<= } Amount bool


Left Operand Operator Right Operand Output
AmountResult * Decimal AmountResult
AmountResult / Decimal AmountResult
AmountResult {+,-} Amount AmountResult
AmountResult {+,-} AmountResult AmountResult
AmountResult {==,!=} Amount bool
AmountResult {==,!=} AmountResult bool
AmountResult {==,!=} CurrencyError bool


Left Operand Operator Right Operand Output
CurrencyError {==,!=} AmountResult bool
CurrencyError {==,!=} CurrencyError bool

Unary Operations


Operator Operand Output
- Amount Amount


Operator Operand Output
- AmountResult AmountResult


~15K SLoC