Allow different calendars to return different year-info types (#6439)

Author: robertbastian

components/calendar/README.md

@@ -18,9 +18,9 @@ fn bench_calendar<C: Clone + Calendar>(
     group.bench_function(name, |b| {
         b.iter(|| {
             let converted = black_box(iso).to_calendar(Ref(&calendar));
-            let year = black_box(converted.year().era_year_or_related_iso());
-            let month = black_box(converted.month().ordinal);
-            let day = black_box(converted.day_of_month().0);
+            let year = black_box(converted.year());
+            let month = black_box(converted.month());
+            let day = black_box(converted.day_of_month());
             black_box((converted, year, month, day))
         })
     });

components/calendar/benches/convert.rs

@@ -21,9 +21,9 @@ fn bench_date<A: AsCalendar>(date: &mut Date<A>) {
     ));
 
     // Retrieving vals
-    let _ = black_box(date.year().era_year_or_related_iso());
-    let _ = black_box(date.month().ordinal);
-    let _ = black_box(date.day_of_month().0);
+    let _ = black_box(date.year());
+    let _ = black_box(date.month());
+    let _ = black_box(date.day_of_month());
 
     // Conversion to ISO.
     let _ = black_box(date.to_iso());

components/calendar/benches/date.rs

@@ -32,7 +32,7 @@ fn main() {
         let date = Date::try_new_iso(year, month, day).expect("date should parse");
         println!(
             "Year: {}, Month: {}, Day: {}",
-            date.year().era_year_or_related_iso(),
+            date.extended_year(),
             date.month().ordinal,
             date.day_of_month().0,
         );

components/calendar/examples/iso_date_manipulations.rs

@@ -12,6 +12,7 @@ use crate::cal::{
     Iso, Japanese, JapaneseExtended, Persian, Roc,
 };
 use crate::error::DateError;
+use crate::types::YearInfo;
 use crate::{types, AsCalendar, Calendar, Date, DateDuration, DateDurationUnit, Ref};
 
 use crate::preferences::{CalendarAlgorithm, HijriCalendarAlgorithm};
@@ -219,6 +220,8 @@ macro_rules! match_cal {
 
 impl Calendar for AnyCalendar {
     type DateInner = AnyDateInner;
+    type Year = YearInfo;
+
     fn from_codes(
         &self,
         era: Option<&str>,
@@ -465,9 +468,14 @@ impl Calendar for AnyCalendar {
         }
     }
 
-    fn year(&self, date: &Self::DateInner) -> types::YearInfo {
-        match_cal_and_date!(match (self, date): (c, d) => c.year(d))
+    fn year_info(&self, date: &Self::DateInner) -> types::YearInfo {
+        match_cal_and_date!(match (self, date): (c, d) => c.year_info(d).into())
+    }
+
+    fn extended_year(&self, date: &Self::DateInner) -> i32 {
+        match_cal_and_date!(match (self, date): (c, d) => c.extended_year(d))
     }
+
     /// The calendar-specific check if `date` is in a leap year
     fn is_in_leap_year(&self, date: &Self::DateInner) -> bool {
         match_cal_and_date!(match (self, date): (c, d) => c.is_in_leap_year(d))

components/calendar/src/any_calendar.rs

@@ -11,7 +11,7 @@
 //!     .expect("Failed to initialize ISO Date instance.");
 //! let date_buddhist = Date::new_from_iso(date_iso, Buddhist);
 //!
-//! assert_eq!(date_buddhist.year().era_year_or_related_iso(), 2513);
+//! assert_eq!(date_buddhist.era_year().year, 2513);
 //! assert_eq!(date_buddhist.month().ordinal, 1);
 //! assert_eq!(date_buddhist.day_of_month().0, 2);
 //! ```
@@ -52,6 +52,7 @@ pub struct Buddhist;
 
 impl Calendar for Buddhist {
     type DateInner = IsoDateInner;
+    type Year = types::EraYear;
 
     fn from_codes(
         &self,
@@ -115,17 +116,17 @@ impl Calendar for Buddhist {
     }
 
     /// The calendar-specific year represented by `date`
-    fn year(&self, date: &Self::DateInner) -> types::YearInfo {
-        let buddhist_year = date.0.year + BUDDHIST_ERA_OFFSET;
-        types::YearInfo::new(
-            buddhist_year,
-            types::EraYear {
-                standard_era: tinystr!(16, "be").into(),
-                formatting_era: types::FormattingEra::Index(0, tinystr!(16, "BE")),
-                era_year: buddhist_year,
-                ambiguity: types::YearAmbiguity::CenturyRequired,
-            },
-        )
+    fn year_info(&self, date: &Self::DateInner) -> Self::Year {
+        types::EraYear {
+            standard_era: tinystr!(16, "be").into(),
+            formatting_era: types::FormattingEra::Index(0, tinystr!(16, "BE")),
+            year: self.extended_year(date),
+            ambiguity: types::YearAmbiguity::CenturyRequired,
+        }
+    }
+
+    fn extended_year(&self, date: &Self::DateInner) -> i32 {
+        Iso.extended_year(date) + BUDDHIST_ERA_OFFSET
     }
 
     fn is_in_leap_year(&self, date: &Self::DateInner) -> bool {
@@ -167,7 +168,7 @@ impl Date<Buddhist> {
     /// let date_buddhist = Date::try_new_buddhist(1970, 1, 2)
     ///     .expect("Failed to initialize Buddhist Date instance.");
     ///
-    /// assert_eq!(date_buddhist.year().era_year_or_related_iso(), 1970);
+    /// assert_eq!(date_buddhist.era_year().year, 1970);
     /// assert_eq!(date_buddhist.month().ordinal, 1);
     /// assert_eq!(date_buddhist.day_of_month().0, 2);
     /// ```
@@ -280,7 +281,7 @@ mod test {
         let iso1 = Date::try_new_iso(iso_year, iso_month, iso_day).unwrap();
         let buddhist1 = iso1.to_calendar(Buddhist);
         assert_eq!(
-            buddhist1.year().era_year_or_related_iso(),
+            buddhist1.era_year().year,
             buddhist_year,
             "Iso -> Buddhist year check failed for case: {case:?}"
         );
@@ -299,7 +300,7 @@ mod test {
             Date::try_new_buddhist(buddhist_year, buddhist_month, buddhist_day).unwrap();
         let iso2 = buddhist2.to_calendar(Iso);
         assert_eq!(
-            iso2.year().era_year_or_related_iso(),
+            iso2.era_year().year,
             iso_year,
             "Buddhist -> Iso year check failed for case: {case:?}"
         );

components/calendar/src/cal/buddhist.rs

@@ -11,8 +11,8 @@
 //! let chinese_date = Date::try_new_chinese_with_calendar(2023, 6, 6, chinese)
 //!     .expect("Failed to initialize Chinese Date instance.");
 //!
-//! assert_eq!(chinese_date.year().era_year_or_related_iso(), 2023);
-//! assert_eq!(chinese_date.year().cyclic().unwrap().get(), 40);
+//! assert_eq!(chinese_date.cyclic_year().related_iso, 2023);
+//! assert_eq!(chinese_date.cyclic_year().year.get(), 40);
 //! assert_eq!(chinese_date.month().ordinal, 6);
 //! assert_eq!(chinese_date.day_of_month().0, 6);
 //! ```
@@ -159,6 +159,7 @@ impl Chinese {
 
 impl Calendar for Chinese {
     type DateInner = ChineseDateInner;
+    type Year = types::CyclicYear;
 
     // Construct a date from era/month codes and fields
     fn from_codes(
@@ -242,15 +243,18 @@ impl Calendar for Chinese {
         Self::DEBUG_NAME
     }
 
-    fn year(&self, date: &Self::DateInner) -> types::YearInfo {
+    fn year_info(&self, date: &Self::DateInner) -> Self::Year {
         let year = date.0 .0.year;
         let cyclic = (year.related_iso - 4).rem_euclid(60) as u8;
         let cyclic = NonZeroU8::new(cyclic + 1).unwrap_or(NonZeroU8::MIN); // 1-indexed
-        types::YearInfo::new_cyclic(
-            chinese_based::Chinese::extended_from_iso(year.related_iso),
-            cyclic,
-            year.related_iso,
-        )
+        types::CyclicYear {
+            year: cyclic,
+            related_iso: year.related_iso,
+        }
+    }
+
+    fn extended_year(&self, date: &Self::DateInner) -> i32 {
+        chinese_based::Chinese::extended_from_iso(date.0 .0.year.related_iso)
     }
 
     fn is_in_leap_year(&self, date: &Self::DateInner) -> bool {
@@ -302,9 +306,8 @@ impl<A: AsCalendar<Calendar = Chinese>> Date<A> {
     ///     Date::try_new_chinese_with_calendar(2023, 6, 11, chinese)
     ///         .expect("Failed to initialize Chinese Date instance.");
     ///
-    /// assert_eq!(date_chinese.year().era_year_or_related_iso(), 2023);
-    /// assert_eq!(date_chinese.year().cyclic().unwrap().get(), 40);
-    /// assert_eq!(date_chinese.year().related_iso(), Some(2023));
+    /// assert_eq!(date_chinese.cyclic_year().related_iso, 2023);
+    /// assert_eq!(date_chinese.cyclic_year().year.get(), 40);
     /// assert_eq!(date_chinese.month().ordinal, 6);
     /// assert_eq!(date_chinese.day_of_month().0, 11);
     /// ```
@@ -460,7 +463,7 @@ mod test {
                     let chinese = Date::from_rata_die(rata_die, chinese);
                     assert_eq!(
                         case.expected_year,
-                        chinese.year().extended_year,
+                        chinese.extended_year(),
                         "[{calendar_type}] Chinese from RD failed, case: {case:?}"
                     );
                     assert_eq!(
@@ -560,12 +563,12 @@ mod test {
             |chinese, _calendar_type| {
                 let chinese = iso.to_calendar(chinese);
 
-                assert_eq!(chinese.year().era_year_or_related_iso(), -2636);
+                assert_eq!(chinese.cyclic_year().related_iso, -2636);
                 assert_eq!(chinese.month().ordinal, 1);
                 assert_eq!(chinese.month().standard_code.0, "M01");
                 assert_eq!(chinese.day_of_month().0, 1);
-                assert_eq!(chinese.year().cyclic().unwrap().get(), 1);
-                assert_eq!(chinese.year().related_iso(), Some(-2636));
+                assert_eq!(chinese.cyclic_year().year.get(), 1);
+                assert_eq!(chinese.cyclic_year().related_iso, -2636);
             },
         )
     }
@@ -613,7 +616,7 @@ mod test {
                     let chinese = iso.to_calendar(chinese);
                     assert_eq!(
                         case.expected_year,
-                        chinese.year().era_year_or_related_iso(),
+                        chinese.cyclic_year().related_iso,
                         "[{calendar_type}] ISO to Chinese failed for case: {case:?}"
                     );
                     assert_eq!(
@@ -1010,18 +1013,17 @@ mod test {
                 &chinese_cached,
                 |chinese, calendar_type| {
                     let chinese = iso.to_calendar(chinese);
-                    let chinese_rel_iso = chinese.year().related_iso();
-                    let chinese_cyclic = chinese.year().cyclic();
+                    let chinese_rel_iso = chinese.cyclic_year().related_iso;
+                    let chinese_cyclic = chinese.cyclic_year().year;
                     let chinese_month = chinese.month().ordinal;
                     let chinese_day = chinese.day_of_month().0;
 
                     assert_eq!(
-                        chinese_rel_iso,
-                        Some(case.expected_rel_iso),
+                        chinese_rel_iso, case.expected_rel_iso,
                         "[{calendar_type}] Related ISO failed for test case: {case:?}"
                     );
                     assert_eq!(
-                        chinese_cyclic.unwrap().get(),
+                        chinese_cyclic.get(),
                         case.expected_cyclic,
                         "[{calendar_type}] Cyclic year failed for test case: {case:?}"
                     );

components/calendar/src/cal/chinese.rs

@@ -11,7 +11,7 @@
 //!     .expect("Failed to initialize ISO Date instance.");
 //! let date_coptic = Date::new_from_iso(date_iso, Coptic);
 //!
-//! assert_eq!(date_coptic.year().era_year_or_related_iso(), 1686);
+//! assert_eq!(date_coptic.era_year().year, 1686);
 //! assert_eq!(date_coptic.month().ordinal, 4);
 //! assert_eq!(date_coptic.day_of_month().0, 24);
 //! ```
@@ -94,6 +94,7 @@ impl CalendarArithmetic for Coptic {
 
 impl Calendar for Coptic {
     type DateInner = CopticDateInner;
+    type Year = types::EraYear;
     fn from_codes(
         &self,
         era: Option<&str>,
@@ -160,31 +161,29 @@ impl Calendar for Coptic {
         date1.0.until(date2.0, _largest_unit, _smallest_unit)
     }
 
-    fn year(&self, date: &Self::DateInner) -> types::YearInfo {
-        let year = date.0.year;
+    fn year_info(&self, date: &Self::DateInner) -> Self::Year {
+        let year = self.extended_year(date);
         if year > 0 {
-            types::YearInfo::new(
+            types::EraYear {
+                standard_era: tinystr!(16, "am").into(),
+                formatting_era: types::FormattingEra::Index(1, tinystr!(16, "AM")),
                 year,
-                types::EraYear {
-                    standard_era: tinystr!(16, "am").into(),
-                    formatting_era: types::FormattingEra::Index(1, tinystr!(16, "AM")),
-                    era_year: year,
-                    ambiguity: types::YearAmbiguity::CenturyRequired,
-                },
-            )
+                ambiguity: types::YearAmbiguity::CenturyRequired,
+            }
         } else {
-            types::YearInfo::new(
-                year,
-                types::EraYear {
-                    standard_era: tinystr!(16, "bd").into(),
-                    formatting_era: types::FormattingEra::Index(0, tinystr!(16, "BD")),
-                    era_year: 1 - year,
-                    ambiguity: types::YearAmbiguity::EraAndCenturyRequired,
-                },
-            )
+            types::EraYear {
+                standard_era: tinystr!(16, "bd").into(),
+                formatting_era: types::FormattingEra::Index(0, tinystr!(16, "BD")),
+                year: 1 - year,
+                ambiguity: types::YearAmbiguity::EraAndCenturyRequired,
+            }
         }
     }
 
+    fn extended_year(&self, date: &Self::DateInner) -> i32 {
+        date.0.extended_year()
+    }
+
     fn is_in_leap_year(&self, date: &Self::DateInner) -> bool {
         Self::provided_year_is_leap(date.0.year)
     }
@@ -221,7 +220,7 @@ impl Date<Coptic> {
     /// let date_coptic = Date::try_new_coptic(1686, 5, 6)
     ///     .expect("Failed to initialize Coptic Date instance.");
     ///
-    /// assert_eq!(date_coptic.year().era_year_or_related_iso(), 1686);
+    /// assert_eq!(date_coptic.era_year().year, 1686);
     /// assert_eq!(date_coptic.month().ordinal, 5);
     /// assert_eq!(date_coptic.day_of_month().0, 6);
     /// ```