Struct Amount 

pub struct Amount {
    pub number: Decimal,
    pub currency: Currency,
}

An amount is a quantity paired with a currency.

Examples

use rustledger_core::Amount;
use rust_decimal_macros::dec;

let amount = Amount::new(dec!(100.00), "USD");
assert_eq!(amount.number, dec!(100.00));
assert_eq!(amount.currency, "USD");

// Arithmetic operations
let other = Amount::new(dec!(50.00), "USD");
let sum = &amount + &other;
assert_eq!(sum.number, dec!(150.00));

Fields

number: Decimal

The decimal quantity

currency: Currency

The currency code (e.g., “USD”, “EUR”, “AAPL”)

Implementations

impl Amount

pub fn new(number: Decimal, currency: impl Into<Currency>) -> Self

Create a new amount.

pub fn zero(currency: impl Into<Currency>) -> Self

Create a zero amount with the given currency.

pub const fn is_zero(&self) -> bool

Check if the amount is zero.

pub const fn is_positive(&self) -> bool

Check if the amount is positive.

pub const fn is_negative(&self) -> bool

Check if the amount is negative.

pub fn abs(&self) -> Self

Get the absolute value of this amount.

pub const fn scale(&self) -> u32

Get the scale (number of decimal places) of this amount.

pub fn inferred_tolerance(&self) -> Decimal

Calculate the inferred tolerance for this amount.

Tolerance is 0.5 * 10^(-scale), so:

• scale 0 (integer) → tolerance 0.5
• scale 1 → tolerance 0.05
• scale 2 → tolerance 0.005

pub fn is_near_zero(&self, tolerance: Decimal) -> bool

Check if this amount is near zero within tolerance.

pub fn is_near(&self, other: &Self, tolerance: Decimal) -> bool

Check if this amount is near another amount within tolerance.

Returns false if currencies don’t match.

pub fn eq_with_tolerance(&self, other: &Self, tolerance: Decimal) -> bool

Check if this amount equals another within the given tolerance.

This is an alias for is_near() with a more explicit name for equality comparison. Returns false if currencies don’t match.

Example

use rustledger_core::Amount;
use rust_decimal_macros::dec;

let a = Amount::new(dec!(100.00), "USD");
let b = Amount::new(dec!(100.004), "USD");

// Within tolerance of 0.005
assert!(a.eq_with_tolerance(&b, dec!(0.005)));

// Outside tolerance of 0.003
assert!(!a.eq_with_tolerance(&b, dec!(0.003)));

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

Check if this amount equals another using auto-inferred tolerance.

The tolerance is computed as the maximum of both amounts’ inferred tolerances, which is based on their decimal precision (scale).

Example

use rustledger_core::Amount;
use rust_decimal_macros::dec;

let a = Amount::new(dec!(100.00), "USD");  // scale 2 -> tolerance 0.005
let b = Amount::new(dec!(100.004), "USD"); // scale 3 -> tolerance 0.0005

// Uses max tolerance (0.005), so these are equal
assert!(a.eq_auto_tolerance(&b));

pub fn round_dp(&self, dp: u32) -> Self

Round this amount to the given number of decimal places.

Trait Implementations

impl Add for &Amount

type Output = Amount

The resulting type after applying the + operator.

fn add(self, other: &Amount) -> Amount

Performs the + operation.

impl Add for Amount

type Output = Amount

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Amount> for Amount

fn add_assign(&mut self, other: &Self)

Performs the += operation.

impl Archive for Amount

where AsDecimal: ArchiveWith<Decimal>, Currency: Archive,

type Archived = ArchivedAmount

The archived representation of this type.

type Resolver = AmountResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for Amount

fn clone(&self) -> Amount

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Amount

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Amount

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<Amount, __D> for Archived<Amount>

where AsDecimal: ArchiveWith<Decimal> + DeserializeWith<<AsDecimal as ArchiveWith<Decimal>>::Archived, Decimal, __D>, Currency: Archive, <Currency as Archive>::Archived: Deserialize<Currency, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Amount, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Display for Amount

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

Formats the value using the given formatter.

impl Eq for Amount

impl From<Amount> for IncompleteAmount

fn from(amount: Amount) -> Self

Converts to this type from the input type.

impl FromStr for Amount

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

Parse <number> <currency> — the exact shape produced by fmt::Display. Round-trip is lossless: Amount::from_str(&amt.to_string()) == Ok(amt).

Strict by design — there is intentionally no Python beancount equivalent of this parser, so we set the wire contract. Accepts:

• Any whitespace (one or more spaces/tabs) between the number and currency.
• Leading or trailing whitespace around the whole string.
• Negative numbers (-100 USD).
• Fractional decimals (100.50 USD).

Rejects (typed error rather than silent fallback):

• Currency-first form ("USD 100").
• Number-only ("100") or currency-only ("USD").
• Scientific notation ("1e2 USD").
• Thousands separators ("1,000 USD").
• Lowercase commodity ("100 usd").
• Empty / whitespace-only strings.

Errors

Returns AmountParseError describing which axis of the expected shape was violated; see AmountParseErrorReason.

type Err = AmountParseError

The associated error which can be returned from parsing.

impl Hash for Amount

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 Neg for &Amount

type Output = Amount

The resulting type after applying the - operator.

fn neg(self) -> Amount

Performs the unary - operation.

impl Neg for Amount

type Output = Amount

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Amount

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for Amount

where AsDecimal: SerializeWith<Decimal, __S>, Currency: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl ShiftSpans for Amount

fn shift_spans<F: Fn(&mut Span)>(&mut self, shift: &F)

Apply shift to every Span reachable in self.

impl StructuralPartialEq for Amount

impl Sub for &Amount

type Output = Amount

The resulting type after applying the - operator.

fn sub(self, other: &Amount) -> Amount

Performs the - operation.

impl Sub for Amount

type Output = Amount

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl SubAssign<&Amount> for Amount

fn sub_assign(&mut self, other: &Self)

Performs the -= operation.