Years type implementation

src/date.rs

@@ -23,6 +23,8 @@ use crate::oldtime::Duration as OldDuration;
 use crate::DateTime;
 use crate::{Datelike, Weekday};
 
+use crate::Years;
+
 /// ISO 8601 calendar date with time zone.
 ///
 /// You almost certainly want to be using a [`NaiveDate`] instead of this type.
@@ -368,6 +370,16 @@ where
     ) -> DelayedFormat<StrftimeItems<'a>> {
         self.format_localized_with_items(StrftimeItems::new_with_locale(fmt, locale), locale)
     }
+
+    pub fn checked_add_years(mut self, num_years: Years) -> Option<Date<Tz>> {
+        self.date = self.date.checked_add_years(num_years)?;
+        Some(self)
+    }
+
+    pub fn checked_sub_years(mut self, num_years: Years) -> Option<Date<Tz>> {
+        self.date = self.date.checked_sub_years(num_years)?;
+        Some(self)
+    }
 }
 
 impl<Tz: TimeZone> Datelike for Date<Tz> {

src/datetime/mod.rs

@@ -35,6 +35,8 @@ use crate::Date;
 use crate::Months;
 use crate::{Datelike, Timelike, Weekday};
 
+use crate::Years;
+
 #[cfg(feature = "rkyv")]
 use rkyv::{Archive, Deserialize, Serialize};
 
@@ -743,6 +745,16 @@ where
     ) -> DelayedFormat<StrftimeItems<'a>> {
         self.format_localized_with_items(StrftimeItems::new_with_locale(fmt, locale), locale)
     }
+
+    pub fn checked_add_years(mut self, num_years: Years) -> Option<DateTime<Tz>> {
+        self.datetime = self.datetime.checked_add_years(num_years)?;
+        Some(self)
+    }
+
+    pub fn checked_sub_years(mut self, num_years: Years) -> Option<DateTime<Tz>> {
+        self.datetime = self.datetime.checked_sub_years(num_years)?;
+        Some(self)
+    }
 }
 
 impl<Tz: TimeZone> Datelike for DateTime<Tz> {

src/lib.rs

@@ -492,6 +492,12 @@ pub use weekday::{ParseWeekdayError, Weekday};
 mod month;
 pub use month::{Month, Months, ParseMonthError};
 
+// I'm not entirely sure too this should be here, because months
+// was implemented at this level and Days at naive level
+// I believe here might be better since it should help avoid coupling
+pub use years::Years;
+mod years; // add pub uses
+
 mod traits;
 pub use traits::{Datelike, Timelike};
 

src/naive/date.rs

@@ -27,6 +27,8 @@ use crate::naive::{IsoWeek, NaiveDateTime, NaiveTime};
 use crate::oldtime::Duration as OldDuration;
 use crate::{Datelike, Duration, Weekday};
 
+use crate::Years;
+
 use super::internals::{self, DateImpl, Mdf, Of, YearFlags};
 use super::isoweek;
 
@@ -1248,6 +1250,23 @@ impl NaiveDate {
         NaiveWeek { date: *self, start }
     }
 
+    // I think self here is a copy, but I still have to make sure it's
+    pub fn checked_add_years(self, years: Years) -> Option<NaiveDate> {
+        if years.0 == 0 {
+            return Some(self);
+        }
+        let num_years = i32::try_from(years.0).ok()?;
+        self.with_year(self.year() + num_years)
+    }
+
+    pub fn checked_sub_years(self, years: Years) -> Option<NaiveDate> {
+        if years.0 == 0 {
+            return Some(self);
+        }
+        let num_years = i32::try_from(years.0).ok()?;
+        self.with_year(self.year() - num_years)
+    }
+
     /// The minimum possible `NaiveDate` (January 1, 262145 BCE).
     pub const MIN: NaiveDate = NaiveDate { ymdf: (MIN_YEAR << 13) | (1 << 4) | 0o07 /*FE*/ };
     /// The maximum possible `NaiveDate` (December 31, 262143 CE).
@@ -1687,6 +1706,22 @@ impl Sub<Months> for NaiveDate {
     }
 }
 
+impl Add<Years> for NaiveDate {
+    type Output = NaiveDate;
+
+    fn add(self, years: Years) -> Self::Output {
+        self.checked_add_years(years).unwrap()
+    }
+}
+
+impl Sub<Years> for NaiveDate {
+    type Output = NaiveDate;
+
+    fn sub(self, years: Years) -> Self::Output {
+        self.checked_sub_years(years).unwrap()
+    }
+}
+
 impl Add<Days> for NaiveDate {
     type Output = NaiveDate;
 

src/naive/datetime/mod.rs

@@ -24,6 +24,8 @@ use crate::oldtime::Duration as OldDuration;
 use crate::{DateTime, Datelike, LocalResult, Months, TimeZone, Timelike, Weekday};
 use core::cmp::Ordering;
 
+use crate::Years;
+
 #[cfg(feature = "rustc-serialize")]
 pub(super) mod rustc_serialize;
 
@@ -927,6 +929,16 @@ impl NaiveDateTime {
             }
         }
     }
+
+    pub fn checked_add_years(mut self, num_years: Years) -> Option<NaiveDateTime> {
+        self.date = self.date.checked_add_years(num_years)?;
+        Some(self)
+    }
+
+    pub fn checked_sub_years(mut self, num_years: Years) -> Option<NaiveDateTime> {
+        self.date = self.date.checked_sub_years(num_years)?;
+        Some(self)
+    }
 }
 
 impl Datelike for NaiveDateTime {

src/years.rs

@@ -0,0 +1,58 @@
+// I usually develop with this clippy flags
+// but I can remove once the this module is done
+#![warn(clippy::all,
+/*#![warn(*/clippy::pedantic,
+		clippy::perf,
+        clippy::nursery,
+        // clippy::cargo,
+        clippy::unwrap_used,
+        clippy::expect_used)]
+
+/// TODO
+#[derive(Debug)]
+pub struct Years(pub(crate) u32); // I believe the fields of the struct should be private
+
+impl Years {
+    /// TODO
+    pub fn new(num_years: u32) -> Years {
+        Self(num_years)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::NaiveDate;
+    use crate::Years;
+
+    #[test]
+    fn checked_adding_years() {
+        assert_eq!(
+            NaiveDate::from_ymd_opt(2023, 2, 28).unwrap(),
+            NaiveDate::from_ymd_opt(2020, 2, 28).unwrap().checked_add_years(Years::new(3)).unwrap()
+        );
+    }
+
+    #[test]
+    fn using_add_operator() {
+        assert_eq!(
+            NaiveDate::from_ymd_opt(2023, 2, 28).unwrap(),
+            NaiveDate::from_ymd_opt(2020, 2, 28).unwrap() + Years::new(3)
+        );
+    }
+
+    #[test]
+    fn checked_subtracting_years() {
+        assert_eq!(
+            NaiveDate::from_ymd_opt(2017, 2, 28).unwrap(),
+            NaiveDate::from_ymd_opt(2020, 2, 28).unwrap().checked_sub_years(Years::new(3)).unwrap()
+        );
+    }
+
+    #[test]
+    fn using_sub_operator() {
+        assert_eq!(
+            NaiveDate::from_ymd_opt(2017, 2, 28).unwrap(),
+            NaiveDate::from_ymd_opt(2020, 2, 28).unwrap() - Years::new(3)
+        );
+    }
+}