Enum Period 

pub enum Period {
    Days(i32),
    Weeks(i32),
    Months(i32),
    Years(i32),
}

A signed duration tagged by its calendar unit.

Each variant carries an i32 length; the unit is the variant.

use fasti::Period;
let p = Period::Months(3);
match p {
    Period::Days(n) => unreachable!("not days, n={n}"),
    Period::Months(n) => assert_eq!(n, 3),
    _ => unreachable!(),
}
// `12M` normalizes to `1Y`.
assert_eq!(Period::Months(12).normalized(), Period::Years(1));
// Scalar multiplication scales the length.
assert_eq!(Period::Months(3) * 4, Period::Months(12));

Variants

Days(i32)

Calendar days.

Weeks(i32)

Weeks — 7 calendar days, no calendar dependency.

Months(i32)

Calendar months — variable length (28..=31 days).

Years(i32)

Calendar years — variable length (365 or 366 days).

Implementations

impl Period

pub const ZERO: Self

The zero period — 0 Days.

pub const fn length(self) -> i32

The signed length component.

use fasti::Period;
assert_eq!(Period::Months(3).length(), 3);
assert_eq!(Period::Days(-7).length(), -7);

pub const fn is_zero(self) -> bool

true iff the period has zero length, regardless of unit.

use fasti::Period;
assert!(Period::ZERO.is_zero());
assert!(Period::Months(0).is_zero());
assert!(!Period::Days(1).is_zero());

pub const fn normalized(self) -> Self

Canonicalize the period — 12 Months → 1 Year, 7 Days → 1 Week; non-multiples are unchanged and zero normalizes to 0 Days.

use fasti::Period;
assert_eq!(Period::Months(24).normalized(), Period::Years(2));
assert_eq!(Period::Days(14).normalized(), Period::Weeks(2));
// Non-multiples stay put.
assert_eq!(Period::Months(5).normalized(), Period::Months(5));
// Zero normalizes to 0 Days regardless of input unit.
assert_eq!(Period::Years(0).normalized(), Period::Days(0));

pub const fn checked_neg(self) -> Option<Self>

Negate the length, returning None on overflow (i32::MIN has no positive counterpart).

use fasti::Period;
assert_eq!(Period::Months(3).checked_neg(), Some(Period::Months(-3)));
assert_eq!(Period::Days(i32::MIN).checked_neg(), None);

pub const fn checked_mul(self, n: i32) -> Option<Self>

Scale the length by n, returning None on overflow.

use fasti::Period;
assert_eq!(Period::Months(3).checked_mul(4), Some(Period::Months(12)));
assert_eq!(Period::Days(i32::MAX).checked_mul(2), None);

Trait Implementations

impl Add<Period> for Date

Step a Date forward by a Period. Returns TimeError::DateOutOfRange for out-of-range results; Months/Years clamp the day-of-month (see Date::add_months).

use fasti::{Date, Month, Period};
let d = Date::from_ymd(2026, Month::Jan, 15)?;
assert_eq!((d + Period::Months(6))?, Date::from_ymd(2026, Month::Jul, 15)?);
assert_eq!((d + Period::Years(1))?, Date::from_ymd(2027, Month::Jan, 15)?);
assert_eq!((d + Period::Days(7))?, Date::from_ymd(2026, Month::Jan, 22)?);
// Negative periods step backward.
assert_eq!((d + (-Period::Months(1)))?, Date::from_ymd(2025, Month::Dec, 15)?);

type Output = Result<Date, TimeError>

The resulting type after applying the + operator.

fn add(self, period: Period) -> Self::Output

Performs the + operation.

impl Clone for Period

fn clone(&self) -> Period

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Period

impl Debug for Period

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Period

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Period

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

Format as QuantLib does: 3M, 1Y, 2W, 14D. Zero-length periods format as 0D.

impl Eq for Period

impl From<Frequency> for Period

fn from(frequency: Frequency) -> Self

Map a Frequency to its canonical Period. Annual maps to 12 Months; call Period::normalized to get 1 Year.

impl Hash for Period

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 Mul<Period> for i32

fn mul(self, period: Period) -> Self::Output

Scalar multiplication with the scalar on the left.

type Output = Period

The resulting type after applying the * operator.

impl Mul<i32> for Period

fn mul(self, n: i32) -> Self::Output

Scale the length by n, preserving the unit. Wraps on overflow; use Period::checked_mul to detect it.

type Output = Period

The resulting type after applying the * operator.

impl Neg for Period

fn neg(self) -> Self::Output

Negate the length. Wraps on i32::MIN; use Period::checked_neg to detect overflow.

type Output = Period

The resulting type after applying the - operator.

impl PartialEq for Period

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Period

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Period

impl Sub<Period> for Date

Step a Date backward by a Period. Uses Period::checked_neg, surfacing i32::MIN overflow as TimeError::DateOutOfRange.

use fasti::{Date, Month, Period};
let d = Date::from_ymd(2026, Month::Jul, 15)?;
assert_eq!((d - Period::Months(6))?, Date::from_ymd(2026, Month::Jan, 15)?);

type Output = Result<Date, TimeError>

The resulting type after applying the - operator.

fn sub(self, period: Period) -> Self::Output

Performs the - operation.

impl TryFrom<Period> for Frequency

fn try_from(period: Period) -> Result<Self, Self::Error>

Map a Period to the canonical Frequency, normalizing first. Non-canonical, zero, and negative periods return TimeError::NonCanonicalPeriod.

type Error = TimeError

The type returned in the event of a conversion error.