Add Eq and Ord for PlainYearMonth + Eq for PlainMonthDay (#175)

This PR adds `Eq` and `Ord` trait implementations for `PlainYearMonth`
and an `Eq` trait impl for `PlainMonthDay` to enable implementing
`Temporal.PlainYearMonth.compare`,
`Temporal.PlainYearMonth.prototype.equals` and
`Temporal.PlainMonthDay.prototype.equals`.

Author: nekevss

src/builtins/core/date.rs

@@ -15,7 +15,7 @@ use crate::{
     TemporalError, TemporalResult, TemporalUnwrap, TimeZone,
 };
 use alloc::{format, string::String};
-use core::str::FromStr;
+use core::{cmp::Ordering, str::FromStr};
 
 use super::{
     calendar::{ascii_four_to_integer, month_to_month_code},
@@ -139,18 +139,6 @@ impl core::fmt::Display for PlainDate {
     }
 }
 
-impl Ord for PlainDate {
-    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
-        self.iso.cmp(&other.iso)
-    }
-}
-
-impl PartialOrd for PlainDate {
-    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
 // ==== Private API ====
 
 impl PlainDate {
@@ -437,6 +425,7 @@ impl PlainDate {
         self.iso.is_valid()
     }
 
+    // TODO: make private
     /// `DaysUntil`
     ///
     /// Calculates the epoch days between two `Date`s
@@ -446,6 +435,20 @@ impl PlainDate {
         other.iso.to_epoch_days() - self.iso.to_epoch_days()
     }
 
+    /// Compares one `PlainDate` to another `PlainDate` using their
+    /// `IsoDate` representation.
+    ///
+    /// # Note on Ordering.
+    ///
+    /// `temporal_rs` does not implement `PartialOrd`/`Ord` as `PlainDate` does
+    /// not fulfill all the conditions required to implement the traits. However,
+    /// it is possible to compare `PlainDate`'s as their `IsoDate` representation.
+    #[inline]
+    #[must_use]
+    pub fn compare_iso(&self, other: &Self) -> Ordering {
+        self.iso.cmp(&other.iso)
+    }
+
     #[inline]
     /// Adds a `Duration` to the current `Date`
     pub fn add(
@@ -639,30 +642,30 @@ mod tests {
         assert!(err.is_err());
         let err = PlainDate::try_new(275_760, 9, 14, Calendar::default());
         assert!(err.is_err());
-        let ok = PlainDate::try_new(-271_821, 4, 19, Calendar::default()).unwrap();
+        let ok = PlainDate::try_new(-271_821, 4, 19, Calendar::default());
         assert_eq!(
             ok,
-            PlainDate {
+            Ok(PlainDate {
                 iso: IsoDate {
                     year: -271_821,
                     month: 4,
                     day: 19,
                 },
                 calendar: Calendar::default(),
-            }
+            })
         );
 
-        let ok = PlainDate::try_new(275_760, 9, 13, Calendar::default()).unwrap();
+        let ok = PlainDate::try_new(275_760, 9, 13, Calendar::default());
         assert_eq!(
             ok,
-            PlainDate {
+            Ok(PlainDate {
                 iso: IsoDate {
                     year: 275760,
                     month: 9,
                     day: 13,
                 },
                 calendar: Calendar::default(),
-            }
+            })
         );
     }
 

src/builtins/core/datetime.rs

@@ -45,18 +45,6 @@ impl core::fmt::Display for PlainDateTime {
     }
 }
 
-impl Ord for PlainDateTime {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.iso.cmp(&other.iso)
-    }
-}
-
-impl PartialOrd for PlainDateTime {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
 // ==== Private PlainDateTime API ====
 
 impl PlainDateTime {
@@ -575,6 +563,20 @@ impl PlainDateTime {
 }
 
 impl PlainDateTime {
+    /// Compares one `PlainDateTime` to another `PlainDateTime` using their
+    /// `IsoDate` representation.
+    ///
+    /// # Note on Ordering.
+    ///
+    /// `temporal_rs` does not implement `PartialOrd`/`Ord` as `PlainDateTime` does
+    /// not fulfill all the conditions required to implement the traits. However,
+    /// it is possible to compare `PlainDate`'s as their `IsoDate` representation.
+    #[inline]
+    #[must_use]
+    pub fn compare_iso(&self, other: &Self) -> Ordering {
+        self.iso.cmp(&other.iso)
+    }
+
     #[inline]
     /// Adds a `Duration` to the current `DateTime`.
     pub fn add(

src/builtins/core/month_day.rs

@@ -14,7 +14,7 @@ use crate::{
 
 /// The native Rust implementation of `Temporal.PlainMonthDay`
 #[non_exhaustive]
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct PlainMonthDay {
     pub iso: IsoDate,
     calendar: Calendar,

src/builtins/core/year_month.rs

@@ -1,7 +1,7 @@
 //! This module implements `YearMonth` and any directly related algorithms.
 
 use alloc::string::String;
-use core::str::FromStr;
+use core::{cmp::Ordering, str::FromStr};
 
 use tinystr::TinyAsciiStr;
 
@@ -17,7 +17,7 @@ use super::{Duration, PartialDate};
 
 /// The native Rust implementation of `Temporal.YearMonth`.
 #[non_exhaustive]
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct PlainYearMonth {
     pub(crate) iso: IsoDate,
     calendar: Calendar,
@@ -72,44 +72,53 @@ impl PlainYearMonth {
         self.iso.month
     }
 
+    /// Returns the calendar era of the current `PlainYearMonth`
+    pub fn era(&self) -> TemporalResult<Option<TinyAsciiStr<16>>> {
+        self.calendar().era(&self.iso)
+    }
+
+    /// Returns the calendar era year of the current `PlainYearMonth`
+    pub fn era_year(&self) -> TemporalResult<Option<i32>> {
+        self.calendar().era_year(&self.iso)
+    }
+
+    /// Returns the calendar year of the current `PlainYearMonth`
     pub fn year(&self) -> TemporalResult<i32> {
         self.calendar().year(&self.iso)
     }
 
+    /// Returns the calendar month of the current `PlainYearMonth`
     pub fn month(&self) -> TemporalResult<u8> {
         self.calendar().month(&self.iso)
     }
 
+    /// Returns the calendar month code of the current `PlainYearMonth`
     pub fn month_code(&self) -> TemporalResult<TinyAsciiStr<4>> {
         self.calendar().month_code(&self.iso)
     }
 
-    #[inline]
-    #[must_use]
-    pub fn in_leap_year(&self) -> bool {
-        self.calendar()
-            .in_leap_year(&self.iso)
-            .is_ok_and(|is_leap_year| is_leap_year)
-    }
-
-    pub fn get_days_in_year(&self) -> TemporalResult<u16> {
+    /// Returns the days in the calendar year of the current `PlainYearMonth`.
+    pub fn days_in_year(&self) -> TemporalResult<u16> {
         self.calendar().days_in_year(&self.iso)
     }
 
-    pub fn get_days_in_month(&self) -> TemporalResult<u16> {
+    /// Returns the days in the calendar month of the current `PlainYearMonth`.
+    pub fn days_in_month(&self) -> TemporalResult<u16> {
         self.calendar().days_in_month(&self.iso)
     }
 
-    pub fn get_months_in_year(&self) -> TemporalResult<u16> {
+    /// Returns the months in the calendar year of the current `PlainYearMonth`.
+    pub fn months_in_year(&self) -> TemporalResult<u16> {
         self.calendar().months_in_year(&self.iso)
     }
 
-    pub fn era(&self) -> TemporalResult<Option<TinyAsciiStr<16>>> {
-        self.calendar().era(&self.iso)
-    }
-
-    pub fn era_year(&self) -> TemporalResult<Option<i32>> {
-        self.calendar().era_year(&self.iso)
+    #[inline]
+    #[must_use]
+    /// Returns a boolean representing whether the current `PlainYearMonth` is in a leap year.
+    pub fn in_leap_year(&self) -> bool {
+        self.calendar()
+            .in_leap_year(&self.iso)
+            .is_ok_and(|is_leap_year| is_leap_year)
     }
 }
 
@@ -128,6 +137,20 @@ impl PlainYearMonth {
         self.calendar.identifier()
     }
 
+    /// Compares one `PlainYearMonth` to another `PlainYearMonth` using their
+    /// `IsoDate` representation.
+    ///
+    /// # Note on Ordering.
+    ///
+    /// `temporal_rs` does not implement `PartialOrd`/`Ord` as `PlainYearMonth` does
+    /// not fulfill all the conditions required to implement the traits. However,
+    /// it is possible to compare `PlainDate`'s as their `IsoDate` representation.
+    #[inline]
+    #[must_use]
+    pub fn compare_iso(&self, other: &Self) -> Ordering {
+        self.iso.cmp(&other.iso)
+    }
+
     pub fn add_duration(
         &self,
         duration: &Duration,

src/builtins/core/zoneddatetime.rs

@@ -1,7 +1,7 @@
 //! This module implements `ZonedDateTime` and any directly related algorithms.
 
 use alloc::string::String;
-use core::num::NonZeroU128;
+use core::{cmp::Ordering, num::NonZeroU128};
 use ixdtf::parsers::records::{TimeZoneRecord, UtcOffsetRecordOrZ};
 use tinystr::TinyAsciiStr;
 
@@ -50,18 +50,6 @@ pub struct ZonedDateTime {
     tz: TimeZone,
 }
 
-impl Ord for ZonedDateTime {
-    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
-        self.instant.cmp(&other.instant)
-    }
-}
-
-impl PartialOrd for ZonedDateTime {
-    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
 // ==== Private API ====
 
 impl ZonedDateTime {
@@ -432,6 +420,20 @@ impl ZonedDateTime {
     pub fn with_calendar(&self, calendar: Calendar) -> TemporalResult<Self> {
         Self::try_new(self.epoch_nanoseconds(), calendar, self.tz.clone())
     }
+
+    /// Compares one `ZonedDateTime` to another `ZonedDateTime` using their
+    /// `Instant` representation.
+    ///
+    /// # Note on Ordering.
+    ///
+    /// `temporal_rs` does not implement `PartialOrd`/`Ord` as `ZonedDateTime` does
+    /// not fulfill all the conditions required to implement the traits. However,
+    /// it is possible to compare `PlainDate`'s as their `IsoDate` representation.
+    #[inline]
+    #[must_use]
+    pub fn compare_instant(&self, other: &Self) -> Ordering {
+        self.instant.cmp(&other.instant)
+    }
 }
 
 // ==== HoursInDay accessor method implementation ====

temporal_capi/src/plain_year_month.rs

@@ -64,13 +64,13 @@ pub mod ffi {
             self.0.in_leap_year()
         }
         pub fn days_in_month(&self) -> Result<u16, TemporalError> {
-            self.0.get_days_in_month().map_err(Into::into)
+            self.0.days_in_month().map_err(Into::into)
         }
         pub fn days_in_year(&self) -> Result<u16, TemporalError> {
-            self.0.get_days_in_year().map_err(Into::into)
+            self.0.days_in_year().map_err(Into::into)
         }
         pub fn months_in_year(&self) -> Result<u16, TemporalError> {
-            self.0.get_months_in_year().map_err(Into::into)
+            self.0.months_in_year().map_err(Into::into)
         }
         // Writes an empty string for no era
         pub fn era(&self, write: &mut DiplomatWrite) -> Result<(), TemporalError> {