Struct EstimatedUsd 

pub struct EstimatedUsd(/* private fields */);

Dollars derived from published rates. Not the bill.

There is deliberately no ActualUsd alongside this: a client that never sees an invoice cannot produce an actual. And there is deliberately no way to get an f64 out (COST-2) — no From<EstimatedUsd> for f64, no Into, no Deref, no as_f64. The Python original could only omit __float__ and hope; the cheapest way to launder an estimate into a bill is f"${float(x):.2f}", and the Rust equivalent does not compile.

EstimatedUsd::amount returns a Decimal, which is one visible step and keeps the type name at the call site. A caller who genuinely needs a float reaches for Decimal::to_f64, which is two named steps and a Option — and which is a decision a reviewer can see.

Add is implemented only against itself, so summing an amount that might be Amount::Unpriced is a type error rather than a silent zero.

The coercion does not compile (COST-2)

The requirement is about an impl that is absent, so the check has to be a program that fails to build. compile_fail doctests are that check, and they are run by cargo test like any other:

The error code is pinned on each one, because a bare compile_fail passes for any build failure — including a typo in the test itself, which would leave the guard green while measuring nothing.

let estimate = EstimatedUsd::new(dec!(1.23));
// No `From<EstimatedUsd> for f64`, so no `Into` either. This is the line the
// Python client could only ask a reader not to write.
let laundered: f64 = estimate.into();

let estimate = EstimatedUsd::new(dec!(1.23));
// No `Deref` and no public field: the figure comes out through `amount()`, which
// names the type at the call site.
let bare = *estimate;

let estimate = EstimatedUsd::new(dec!(1.23));
let unknown = Amount::unpriced("no rate is published");
// `Add` is implemented only against `EstimatedUsd`, so the Python's runtime
// `TypeError` from `NotImplemented` is a compile error here (COST-4).
let wrong = estimate + unknown;

Implementations

impl EstimatedUsd

pub const ZERO: EstimatedUsd

Zero dollars, which is a legitimate priced figure — a zero-length hold, a zero-cycle comparison — and is not the same claim as Amount::Unpriced.

pub fn new(amount: Decimal) -> EstimatedUsd

An estimate from a decimal figure already in the money path.

Takes a Decimal and not an f64, so this constructor cannot be the second float boundary: gb_decimal and seconds_of are the only two, which is what makes COST-6’s “exactly once” checkable by reading them.

pub fn amount(self) -> Decimal

The figure, in decimal.

The one visible step out. Deliberately not Into<Decimal>: an explicit call keeps EstimatedUsd in the reader’s view at the point the label is dropped.

pub fn amount_string(self) -> String

The figure rendered at display precision, without the estimate label.

For a caller assembling its own sentence. fmt::Display is what carries the label, and it is what a report renders through.

pub fn parse(text: &str) -> Result<EstimatedUsd, Error>

A dollar figure from a caller’s decimal string — a budget, typically.

A string and not an f64, so this is not a third float boundary beside gb_decimal and seconds_of: the caller typed a decimal, and parsing the text they typed keeps 0.1 meaning a tenth rather than the nearest binary float. Negative is refused here rather than compared later, because every total this could be compared against is non-negative and a negative budget can only ever be a sign error the comparison would launder into “always breached”.

Trait Implementations

impl Add for EstimatedUsd

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

Only an estimate adds to an estimate.

There is no Add<Amount> and no Add<Unpriced>, so the Python’s NotImplemented — a runtime TypeError — becomes a compile error. This is the last line of defence for COST-4: even a consumer that ignores CostReport::is_complete cannot sum an unknown into a dollar figure.

type Output = EstimatedUsd

The resulting type after applying the + operator.

impl Clone for EstimatedUsd

fn clone(&self) -> EstimatedUsd

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for EstimatedUsd

impl Debug for EstimatedUsd

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

Formats the value using the given formatter.

impl Display for EstimatedUsd

A figure copied out of a terminal loses its docstring, so the label travels in Display rather than sitting in the type name alone.

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

Formats the value using the given formatter.

impl Eq for EstimatedUsd

impl Ord for EstimatedUsd

fn cmp(&self, other: &EstimatedUsd) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for EstimatedUsd

fn eq(&self, other: &EstimatedUsd) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for EstimatedUsd

fn partial_cmp(&self, other: &EstimatedUsd) -> 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 StructuralPartialEq for EstimatedUsd

impl Sum for EstimatedUsd

fn sum<I>(iter: I) -> EstimatedUsd

where I: Iterator<Item = EstimatedUsd>,

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