Enum FinanceError 

#[non_exhaustive]
pub enum FinanceError {
    NonFinite {
        field: &'static str,
        value: f64,
    },
    InvalidRate {
        rate: f64,
    },
    InvalidPeriod {
        period: u32,
        periods: u32,
        message: &'static str,
    },
    ZeroValue {
        field: &'static str,
    },
    SameSignValues {
        present_value: f64,
        future_value: f64,
    },
    Unsolvable {
        message: &'static str,
    },
    InvalidCashflow {
        message: &'static str,
    },
    EmptyInput {
        what: &'static str,
    },
    LengthMismatch {
        left: usize,
        right: usize,
        context: &'static str,
    },
}

Domain and input errors from finance calculations.

Marked non_exhaustive so new variants can appear in minor releases without breaking downstream match expressions that include a wildcard arm.

Examples

Pattern-match for recovery or user-facing messages:

use finance_solution::{payment, FinanceError};

match payment(-1.5, 36, 10_000.0, 0.0, false) {
    Ok(fv) => println!("fv = {fv}"),
    Err(FinanceError::InvalidRate { rate }) => {
        assert!(rate < -1.0);
        println!("bad rate: {rate} (code={})", FinanceError::InvalidRate { rate }.code());
    }
    Err(FinanceError::NonFinite { field, value }) => {
        println!("{field} was non-finite ({value})");
    }
    Err(e) => println!("other finance error: {e}"),
}

Propagate with ?:

use finance_solution::{present_value, future_value, FinanceResult};

fn round_trip(rate: f64, n: u32, fv: f64) -> FinanceResult<f64> {
    let pv = present_value(rate, n, fv, false)?;
    future_value(rate, n, pv, false)
}

let back = round_trip(0.04, 5, 10_000.0).unwrap();
assert!((back.abs() - 10_000.0).abs() < 1e-6);
assert!(round_trip(-2.0, 5, 10_000.0).is_err());

Zero-value failure (present value of a zero future value is undefined):

use finance_solution::{present_value, FinanceError};

match present_value(0.05, 10, 0.0, false) {
    Err(FinanceError::ZeroValue { field }) => assert_eq!(field, "future_value"),
    other => panic!("expected ZeroValue, got {other:?}"),
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NonFinite

A numeric field was NaN or infinite.

Fields

field: &'static str

value: f64

InvalidRate

Periodic rate outside the allowed domain for the formula (typically < -1.0 or <= -1.0).

Fields

rate: f64

InvalidPeriod

Period index or count is out of range for the calculation.

Fields

period: u32

periods: u32

message: &'static str

ZeroValue

A required money amount was zero (or subnormal) when a nonzero value is required.

Fields

field: &'static str

SameSignValues

Present and future value have the same sign when opposite signs are required.

Fields

present_value: f64

future_value: f64

Unsolvable

Inputs make the equation unsolvable (e.g. zero periods with nonzero cash difference).

Fields

message: &'static str

InvalidCashflow

Cashflow / payment constraint violated (sign, missing values, etc.).

Fields

message: &'static str

EmptyInput

A required collection or series was empty.

Fields

what: &'static str

LengthMismatch

Two series or slices that must align have different lengths.

Fields

left: usize

right: usize

context: &'static str

Implementations

impl FinanceError

pub fn code(&self) -> &'static str

Stable snake_case code for logs and metrics (not localized).

Trait Implementations

impl Clone for FinanceError

fn clone(&self) -> FinanceError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FinanceError

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

Formats the value using the given formatter.

impl Display for FinanceError

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

Formats the value using the given formatter.

impl Error for FinanceError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl PartialEq for FinanceError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FinanceError