Enum PositiveError 

pub enum PositiveError {
    InvalidValue {
        value: String,
        reason: String,
    },
    ArithmeticError {
        operation: String,
        reason: String,
    },
    ConversionError {
        from_type: String,
        to_type: String,
        reason: String,
    },
    OutOfBounds {
        value: Decimal,
        min: Decimal,
        max: Decimal,
    },
    InvalidPrecision {
        precision: u32,
        reason: String,
    },
}

Positive, the non-negative decimal newtype, its error and the is_positive::<T>() type check. Defined by the standalone positive crate and re-exported unchanged: a value obtained through this path is a positive::Positive (see the crate-level “Foundational types” table). Represents errors that can occur during positive decimal operations.

This enum provides a structured way to handle various error conditions that may arise when working with positive decimal values, including validation, arithmetic operations, conversions, and precision issues.

See the module documentation for the stable variant set and the rationale behind the field types.

Examples

use positive::{Positive, PositiveError};

let err = Positive::new(-1.0).unwrap_err();
assert!(matches!(err, PositiveError::OutOfBounds { .. }));
assert!(err.to_string().starts_with("value -1 is out of bounds"));

Variants

InvalidValue

Error when attempting to create a positive decimal from an invalid value.

Occurs when a value cannot be interpreted as a decimal at all — NaN, ±inf, or text that does not parse. Values that are well-formed decimals but fall outside the permitted range produce PositiveError::OutOfBounds instead.

value holds the offending input rendered exactly as it was supplied.

Fields

value: String

The problematic input, rendered exactly as supplied.

reason: String

Detailed explanation of why the value is invalid.

ArithmeticError

Error when performing decimal arithmetic operations.

Occurs during mathematical operations such as addition, subtraction, multiplication, or division when the operation cannot be completed correctly (e.g., division by zero, overflow, result would be negative).

Fields

operation: String

The operation that failed (e.g., “subtraction”, “division”).

reason: String

Detailed explanation of why the operation failed.

ConversionError

Error when converting between decimal types.

Occurs when a value is well-formed but cannot be represented in the destination type — for example a Decimal larger than u64::MAX, or an f64 outside the range Decimal can hold.

Fields

from_type: String

The source type being converted from.

to_type: String

The destination type being converted to.

reason: String

Detailed explanation of why the conversion failed.

OutOfBounds

Error when a decimal value falls outside the permitted range.

All three fields are exact Decimal values. min is the minimum of the type being built: 0 for Positive, and 1e-28 (the smallest strictly positive Decimal) for StrictlyPositive.

Fields

value: Decimal

The value that is out of bounds.

min: Decimal

The minimum acceptable value, inclusive.

max: Decimal

The maximum acceptable value, inclusive.

InvalidPrecision

Error when decimal precision is invalid.

Occurs when an operation specifies a number of decimal places outside the range rust_decimal::Decimal supports (0 through 28 inclusive).

Fields

precision: u32

The problematic precision value, in decimal places.

reason: String

Detailed explanation of why the precision is invalid.

Implementations

impl PositiveError

pub fn invalid_value(value: &str, reason: &str) -> PositiveError

Creates a new InvalidValue error.

Arguments

• value - The problematic input, rendered exactly as supplied
• reason - Explanation of why the value is invalid

Returns

A new PositiveError::InvalidValue instance

Examples

use positive::PositiveError;

let err = PositiveError::invalid_value("NaN", "not a number");
assert_eq!(err.to_string(), "invalid positive value 'NaN': not a number");

pub fn arithmetic_error(operation: &str, reason: &str) -> PositiveError

Creates a new ArithmeticError error.

Arguments

• operation - The name of the operation that failed
• reason - Explanation of why the operation failed

Returns

A new PositiveError::ArithmeticError instance

Examples

use positive::PositiveError;

let err = PositiveError::arithmetic_error("division", "division by zero");
assert_eq!(
    err.to_string(),
    "arithmetic error during division: division by zero"
);

pub fn conversion_error( from_type: &str, to_type: &str, reason: &str, ) -> PositiveError

Creates a new ConversionError error.

Arguments

• from_type - The source type being converted from
• to_type - The destination type being converted to
• reason - Explanation of why the conversion failed

Returns

A new PositiveError::ConversionError instance

Examples

use positive::PositiveError;

let err = PositiveError::conversion_error("Positive", "u64", "value exceeds u64::MAX");
assert_eq!(
    err.to_string(),
    "failed to convert from Positive to u64: value exceeds u64::MAX"
);

pub fn out_of_bounds( value: Decimal, min: Decimal, max: Decimal, ) -> PositiveError

Creates a new OutOfBounds error.

Arguments

• value - The out-of-bounds value, exact
• min - The lower bound (inclusive) of the valid range
• max - The upper bound (inclusive) of the valid range

Returns

A new PositiveError::OutOfBounds instance

Examples

use positive::PositiveError;
use rust_decimal::Decimal;
use rust_decimal_macros::dec;

let err = PositiveError::out_of_bounds(dec!(-5), Decimal::ZERO, Decimal::MAX);
assert!(err.to_string().starts_with("value -5 is out of bounds"));

pub fn invalid_precision(precision: u32, reason: &str) -> PositiveError

Creates a new InvalidPrecision error.

Arguments

• precision - The problematic precision, in decimal places
• reason - Explanation of why the precision is invalid

Returns

A new PositiveError::InvalidPrecision instance

Examples

use positive::PositiveError;

let err = PositiveError::invalid_precision(29, "decimal supports at most 28 places");
assert_eq!(
    err.to_string(),
    "invalid precision 29: decimal supports at most 28 places"
);

Trait Implementations

impl Clone for PositiveError

fn clone(&self) -> PositiveError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PositiveError

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

Formats the value using the given formatter.

impl Display for PositiveError

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

Formats the value using the given formatter.

impl Eq for PositiveError

impl Error for PositiveError

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 From<PositiveError> for ExpirationDateError

fn from(source: PositiveError) -> ExpirationDateError

Converts to this type from the input type.

impl From<PositiveError> for PositionError

fn from(source: PositiveError) -> Self

Converts to this type from the input type.

impl PartialEq for PositiveError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PositiveError