Add checked_sub for Instant and SystemTime

faern · faern · commit 8111824a26f9 · 2018-12-11T09:48:44.000+01:00
diff --git a/src/libstd/sys/cloudabi/time.rs b/src/libstd/sys/cloudabi/time.rs
@@ -25,11 +25,6 @@ fn checked_dur2intervals(dur: &Duration) -> Option<abi::timestamp> {
         .checked_add(dur.subsec_nanos() as abi::timestamp)
 }
 
-pub fn dur2intervals(dur: &Duration) -> abi::timestamp {
-    checked_dur2intervals(dur)
-        .expect("overflow converting duration to nanoseconds")
-}
-
 impl Instant {
     pub fn now() -> Instant {
         unsafe {
@@ -48,17 +43,15 @@ impl Instant {
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-        checked_dur2intervals(other)?
-            .checked_add(self.t)
-            .map(|t| Instant {t})
+        Some(Instant {
+            t: self.t.checked_add(checked_dur2intervals(other)?)?,
+        })
     }
 
-    pub fn sub_duration(&self, other: &Duration) -> Instant {
-        Instant {
-            t: self.t
-                .checked_sub(dur2intervals(other))
-                .expect("overflow when subtracting duration from instant"),
-        }
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant {
+            t: self.t.checked_sub(checked_dur2intervals(other)?)?,
+        })
     }
 }
 
@@ -94,17 +87,15 @@ impl SystemTime {
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        checked_dur2intervals(other)
-            .and_then(|d| self.t.checked_add(d))
-            .map(|t| SystemTime {t})
+        Some(SystemTime {
+            t: self.t.checked_add(checked_dur2intervals(other)?)?,
+        })
     }
 
-    pub fn sub_duration(&self, other: &Duration) -> SystemTime {
-        SystemTime {
-            t: self.t
-                .checked_sub(dur2intervals(other))
-                .expect("overflow when subtracting duration from instant"),
-        }
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime {
+            t: self.t.checked_sub(checked_dur2intervals(other)?)?,
+        })
     }
 }
 
diff --git a/src/libstd/sys/redox/time.rs b/src/libstd/sys/redox/time.rs
@@ -63,27 +63,25 @@ impl Timespec {
         })
     }
 
-    fn sub_duration(&self, other: &Duration) -> Timespec {
+    fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = other
             .as_secs()
             .try_into() // <- target type would be `i64`
             .ok()
-            .and_then(|secs| self.t.tv_sec.checked_sub(secs))
-            .expect("overflow when subtracting duration from time");
+            .and_then(|secs| self.t.tv_sec.checked_sub(secs))?;
 
         // Similar to above, nanos can't overflow.
         let mut nsec = self.t.tv_nsec as i32 - other.subsec_nanos() as i32;
         if nsec < 0 {
             nsec += NSEC_PER_SEC as i32;
-            secs = secs.checked_sub(1).expect("overflow when subtracting \
-                                               duration from time");
+            secs = secs.checked_sub(1)?;
         }
-        Timespec {
+        Some(Timespec {
             t: syscall::TimeSpec {
                 tv_sec: secs,
                 tv_nsec: nsec as i32,
             },
-        }
+        })
     }
 }
 
@@ -147,11 +145,11 @@ impl Instant {
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-        self.t.checked_add_duration(other).map(|t| Instant { t })
+        Some(Instant { t: self.t.checked_add_duration(other)? })
     }
 
-    pub fn sub_duration(&self, other: &Duration) -> Instant {
-        Instant { t: self.t.sub_duration(other) }
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant { t: self.t.checked_sub_duration(other)? })
     }
 }
 
@@ -175,11 +173,11 @@ impl SystemTime {
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        self.t.checked_add_duration(other).map(|t| SystemTime { t })
+        Some(SystemTime { t: self.t.checked_add_duration(other)? })
     }
 
-    pub fn sub_duration(&self, other: &Duration) -> SystemTime {
-        SystemTime { t: self.t.sub_duration(other) }
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime { t: self.t.checked_sub_duration(other)? })
     }
 }
 
diff --git a/src/libstd/sys/unix/time.rs b/src/libstd/sys/unix/time.rs
@@ -64,27 +64,25 @@ impl Timespec {
         })
     }
 
-    fn sub_duration(&self, other: &Duration) -> Timespec {
+    fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = other
             .as_secs()
             .try_into() // <- target type would be `libc::time_t`
             .ok()
-            .and_then(|secs| self.t.tv_sec.checked_sub(secs))
-            .expect("overflow when subtracting duration from time");
+            .and_then(|secs| self.t.tv_sec.checked_sub(secs))?;
 
         // Similar to above, nanos can't overflow.
         let mut nsec = self.t.tv_nsec as i32 - other.subsec_nanos() as i32;
         if nsec < 0 {
             nsec += NSEC_PER_SEC as i32;
-            secs = secs.checked_sub(1).expect("overflow when subtracting \
-                                               duration from time");
+            secs = secs.checked_sub(1)?;
         }
-        Timespec {
+        Some(Timespec {
             t: libc::timespec {
                 tv_sec: secs,
                 tv_nsec: nsec as _,
             },
-        }
+        })
     }
 }
 
@@ -162,14 +160,15 @@ mod inner {
         }
 
         pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-            checked_dur2intervals(other)?.checked_add(self.t).map(|t| Instant {t})
+            Some(Instant {
+                t: self.t.checked_add(checked_dur2intervals(other)?)?,
+            })
         }
 
-        pub fn sub_duration(&self, other: &Duration) -> Instant {
-            Instant {
-                t: self.t.checked_sub(dur2intervals(other))
-                       .expect("overflow when subtracting duration from instant"),
-            }
+        pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+            Some(Instant {
+                t: self.t.checked_sub(checked_dur2intervals(other)?)?,
+            })
         }
     }
 
@@ -193,11 +192,11 @@ mod inner {
         }
 
         pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-            self.t.checked_add_duration(other).map(|t| SystemTime { t })
+            Some(SystemTime { t: self.t.checked_add_duration(other)? })
         }
 
-        pub fn sub_duration(&self, other: &Duration) -> SystemTime {
-            SystemTime { t: self.t.sub_duration(other) }
+        pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+            Some(SystemTime { t: self.t.checked_sub_duration(other)? })
         }
     }
 
@@ -225,11 +224,6 @@ mod inner {
         }
     }
 
-    fn dur2intervals(dur: &Duration) -> u64 {
-        checked_dur2intervals(dur)
-            .expect("overflow converting duration to nanoseconds")
-    }
-
     fn checked_dur2intervals(dur: &Duration) -> Option<u64> {
         let nanos = dur.as_secs()
             .checked_mul(NSEC_PER_SEC)?
@@ -294,11 +288,11 @@ mod inner {
         }
 
         pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-            self.t.checked_add_duration(other).map(|t| Instant { t })
+            Some(Instant { t: self.t.checked_add_duration(other)? })
         }
 
-        pub fn sub_duration(&self, other: &Duration) -> Instant {
-            Instant { t: self.t.sub_duration(other) }
+        pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+            Some(Instant { t: self.t.checked_sub_duration(other)? })
         }
     }
 
@@ -322,11 +316,11 @@ mod inner {
         }
 
         pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-            self.t.checked_add_duration(other).map(|t| SystemTime { t })
+            Some(SystemTime { t: self.t.checked_add_duration(other)? })
         }
 
-        pub fn sub_duration(&self, other: &Duration) -> SystemTime {
-            SystemTime { t: self.t.sub_duration(other) }
+        pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+            Some(SystemTime { t: self.t.checked_sub_duration(other)? })
         }
     }
 
diff --git a/src/libstd/sys/wasm/time.rs b/src/libstd/sys/wasm/time.rs
@@ -29,11 +29,11 @@ impl Instant {
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-        self.0.checked_add(*other).map(|d| Instant(d))
+        Some(Instant(self.0.checked_add(*other)?))
     }
 
-    pub fn sub_duration(&self, other: &Duration) -> Instant {
-        Instant(self.0 - *other)
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant(self.0.checked_sub(*other)?))
     }
 }
 
@@ -48,10 +48,10 @@ impl SystemTime {
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        self.0.checked_add(*other).map(|d| SystemTime(d))
+        Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    pub fn sub_duration(&self, other: &Duration) -> SystemTime {
-        SystemTime(self.0 - *other)
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/src/libstd/sys/windows/time.rs b/src/libstd/sys/windows/time.rs
@@ -79,16 +79,16 @@ impl Instant {
         })
     }
 
-    pub fn sub_duration(&self, other: &Duration) -> Instant {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
         let freq = frequency() as u64;
         let t = other.as_secs().checked_mul(freq).and_then(|i| {
             (self.t as u64).checked_sub(i)
         }).and_then(|i| {
             i.checked_sub(mul_div_u64(other.subsec_nanos() as u64, freq, NANOS_PER_SEC))
-        }).expect("overflow when subtracting duration from time");
-        Instant {
+        })?;
+        Some(Instant {
             t: t as c::LARGE_INTEGER,
-        }
+        })
     }
 }
 
@@ -125,15 +125,13 @@ impl SystemTime {
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        checked_dur2intervals(other)
-            .and_then(|d| self.intervals().checked_add(d))
-            .map(|i| SystemTime::from_intervals(i))
+        let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;
+        Some(SystemTime::from_intervals(intervals))
     }
 
-    pub fn sub_duration(&self, other: &Duration) -> SystemTime {
-        let intervals = self.intervals().checked_sub(dur2intervals(other))
-                            .expect("overflow when subtracting from time");
-        SystemTime::from_intervals(intervals)
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        let intervals = self.intervals().checked_sub(checked_dur2intervals(other)?)?;
+        Some(SystemTime::from_intervals(intervals))
     }
 }
 
@@ -185,11 +183,6 @@ fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
         .ok()
 }
 
-fn dur2intervals(d: &Duration) -> i64 {
-    checked_dur2intervals(d)
-        .expect("overflow when converting duration to intervals")
-}
-
 fn intervals2dur(intervals: u64) -> Duration {
     Duration::new(intervals / INTERVALS_PER_SEC,
                   ((intervals % INTERVALS_PER_SEC) * 100) as u32)
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
@@ -216,6 +216,14 @@ impl Instant {
     pub fn checked_add(&self, duration: Duration) -> Option<Instant> {
         self.0.checked_add_duration(&duration).map(|t| Instant(t))
     }
+
+    /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
+    /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
+    /// otherwise.
+    #[unstable(feature = "time_checked_add", issue = "55940")]
+    pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
+        self.0.checked_sub_duration(&duration).map(|t| Instant(t))
+    }
 }
 
 #[stable(feature = "time2", since = "1.8.0")]
@@ -240,7 +248,8 @@ impl Sub<Duration> for Instant {
     type Output = Instant;
 
     fn sub(self, other: Duration) -> Instant {
-        Instant(self.0.sub_duration(&other))
+        self.checked_sub(other)
+            .expect("overflow when subtracting duration from instant")
     }
 }
 
@@ -374,6 +383,14 @@ impl SystemTime {
     pub fn checked_add(&self, duration: Duration) -> Option<SystemTime> {
         self.0.checked_add_duration(&duration).map(|t| SystemTime(t))
     }
+
+    /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
+    /// `SystemTime` (which means it's inside the bounds of the underlying data structure), `None`
+    /// otherwise.
+    #[unstable(feature = "time_checked_add", issue = "55940")]
+    pub fn checked_sub(&self, duration: Duration) -> Option<SystemTime> {
+        self.0.checked_sub_duration(&duration).map(|t| SystemTime(t))
+    }
 }
 
 #[stable(feature = "time2", since = "1.8.0")]
@@ -398,7 +415,8 @@ impl Sub<Duration> for SystemTime {
     type Output = SystemTime;
 
     fn sub(self, dur: Duration) -> SystemTime {
-        SystemTime(self.0.sub_duration(&dur))
+        self.checked_sub(dur)
+            .expect("overflow when subtracting duration from instant")
     }
 }
 
@@ -531,6 +549,7 @@ mod tests {
 
         let second = Duration::new(1, 0);
         assert_almost_eq!(a - second + second, a);
+        assert_almost_eq!(a.checked_sub(second).unwrap().checked_add(second).unwrap(), a);
 
         // checked_add_duration will not panic on overflow
         let mut maybe_t = Some(Instant::now());
@@ -580,6 +599,7 @@ mod tests {
                            .duration(), second);
 
         assert_almost_eq!(a - second + second, a);
+        assert_almost_eq!(a.checked_sub(second).unwrap().checked_add(second).unwrap(), a);
 
         // A difference of 80 and 800 years cannot fit inside a 32-bit time_t
         if !(cfg!(unix) && ::mem::size_of::<::libc::time_t>() <= 4) {

Original file line number	Diff line number	Diff line change
`@@ -63,27 +63,25 @@ impl Timespec {`
`63`	`63`	`})`
`64`	`64`	`}`
`65`	`65`
`66`		`- fn sub_duration(&self, other: &Duration) -> Timespec {`
	`66`	`+ fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {`
`67`	`67`	`let mut secs = other`
`68`	`68`	`.as_secs()`
`69`	`69`	.try_into() // <- target type would be `i64`
`70`	`70`	`.ok()`
`71`		`- .and_then(\|secs\| self.t.tv_sec.checked_sub(secs))`
`72`		`- .expect("overflow when subtracting duration from time");`
	`71`	`+ .and_then(\|secs\| self.t.tv_sec.checked_sub(secs))?;`
`73`	`72`
`74`	`73`	`// Similar to above, nanos can't overflow.`
`75`	`74`	`let mut nsec = self.t.tv_nsec as i32 - other.subsec_nanos() as i32;`
`76`	`75`	`if nsec < 0 {`
`77`	`76`	`nsec += NSEC_PER_SEC as i32;`
`78`		`- secs = secs.checked_sub(1).expect("overflow when subtracting \`
`79`		`- duration from time");`
	`77`	`+ secs = secs.checked_sub(1)?;`
`80`	`78`	`}`
`81`		`- Timespec {`
	`79`	`+ Some(Timespec {`
`82`	`80`	`t: syscall::TimeSpec {`
`83`	`81`	`tv_sec: secs,`
`84`	`82`	`tv_nsec: nsec as i32,`
`85`	`83`	`},`
`86`		`- }`
	`84`	`+ })`
`87`	`85`	`}`
`88`	`86`	`}`
`89`	`87`
`@@ -147,11 +145,11 @@ impl Instant {`
`147`	`145`	`}`
`148`	`146`
`149`	`147`	`pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {`
`150`		`- self.t.checked_add_duration(other).map(\|t\| Instant { t })`
	`148`	`+ Some(Instant { t: self.t.checked_add_duration(other)? })`
`151`	`149`	`}`
`152`	`150`
`153`		`- pub fn sub_duration(&self, other: &Duration) -> Instant {`
`154`		`- Instant { t: self.t.sub_duration(other) }`
	`151`	`+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {`
	`152`	`+ Some(Instant { t: self.t.checked_sub_duration(other)? })`
`155`	`153`	`}`
`156`	`154`	`}`
`157`	`155`
`@@ -175,11 +173,11 @@ impl SystemTime {`
`175`	`173`	`}`
`176`	`174`
`177`	`175`	`pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`178`		`- self.t.checked_add_duration(other).map(\|t\| SystemTime { t })`
	`176`	`+ Some(SystemTime { t: self.t.checked_add_duration(other)? })`
`179`	`177`	`}`
`180`	`178`
`181`		`- pub fn sub_duration(&self, other: &Duration) -> SystemTime {`
`182`		`- SystemTime { t: self.t.sub_duration(other) }`
	`179`	`+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`180`	`+ Some(SystemTime { t: self.t.checked_sub_duration(other)? })`
`183`	`181`	`}`
`184`	`182`	`}`
`185`	`183`
Original file line number	Diff line number	Diff line change
`@@ -64,27 +64,25 @@ impl Timespec {`
`64`	`64`	`})`
`65`	`65`	`}`
`66`	`66`
`67`		`- fn sub_duration(&self, other: &Duration) -> Timespec {`
	`67`	`+ fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {`
`68`	`68`	`let mut secs = other`
`69`	`69`	`.as_secs()`
`70`	`70`	.try_into() // <- target type would be `libc::time_t`
`71`	`71`	`.ok()`
`72`		`- .and_then(\|secs\| self.t.tv_sec.checked_sub(secs))`
`73`		`- .expect("overflow when subtracting duration from time");`
	`72`	`+ .and_then(\|secs\| self.t.tv_sec.checked_sub(secs))?;`
`74`	`73`
`75`	`74`	`// Similar to above, nanos can't overflow.`
`76`	`75`	`let mut nsec = self.t.tv_nsec as i32 - other.subsec_nanos() as i32;`
`77`	`76`	`if nsec < 0 {`
`78`	`77`	`nsec += NSEC_PER_SEC as i32;`
`79`		`- secs = secs.checked_sub(1).expect("overflow when subtracting \`
`80`		`- duration from time");`
	`78`	`+ secs = secs.checked_sub(1)?;`
`81`	`79`	`}`
`82`		`- Timespec {`
	`80`	`+ Some(Timespec {`
`83`	`81`	`t: libc::timespec {`
`84`	`82`	`tv_sec: secs,`
`85`	`83`	`tv_nsec: nsec as _,`
`86`	`84`	`},`
`87`		`- }`
	`85`	`+ })`
`88`	`86`	`}`
`89`	`87`	`}`
`90`	`88`
`@@ -162,14 +160,15 @@ mod inner {`
`162`	`160`	`}`
`163`	`161`
`164`	`162`	`pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {`
`165`		`- checked_dur2intervals(other)?.checked_add(self.t).map(\|t\| Instant {t})`
	`163`	`+ Some(Instant {`
	`164`	`+ t: self.t.checked_add(checked_dur2intervals(other)?)?,`
	`165`	`+ })`
`166`	`166`	`}`
`167`	`167`
`168`		`- pub fn sub_duration(&self, other: &Duration) -> Instant {`
`169`		`- Instant {`
`170`		`- t: self.t.checked_sub(dur2intervals(other))`
`171`		`- .expect("overflow when subtracting duration from instant"),`
`172`		`- }`
	`168`	`+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {`
	`169`	`+ Some(Instant {`
	`170`	`+ t: self.t.checked_sub(checked_dur2intervals(other)?)?,`
	`171`	`+ })`
`173`	`172`	`}`
`174`	`173`	`}`
`175`	`174`
`@@ -193,11 +192,11 @@ mod inner {`
`193`	`192`	`}`
`194`	`193`
`195`	`194`	`pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`196`		`- self.t.checked_add_duration(other).map(\|t\| SystemTime { t })`
	`195`	`+ Some(SystemTime { t: self.t.checked_add_duration(other)? })`
`197`	`196`	`}`
`198`	`197`
`199`		`- pub fn sub_duration(&self, other: &Duration) -> SystemTime {`
`200`		`- SystemTime { t: self.t.sub_duration(other) }`
	`198`	`+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`199`	`+ Some(SystemTime { t: self.t.checked_sub_duration(other)? })`
`201`	`200`	`}`
`202`	`201`	`}`
`203`	`202`
`@@ -225,11 +224,6 @@ mod inner {`
`225`	`224`	`}`
`226`	`225`	`}`
`227`	`226`
`228`		`- fn dur2intervals(dur: &Duration) -> u64 {`
`229`		`- checked_dur2intervals(dur)`
`230`		`- .expect("overflow converting duration to nanoseconds")`
`231`		`- }`
`232`		`-`
`233`	`227`	`fn checked_dur2intervals(dur: &Duration) -> Option<u64> {`
`234`	`228`	`let nanos = dur.as_secs()`
`235`	`229`	`.checked_mul(NSEC_PER_SEC)?`
`@@ -294,11 +288,11 @@ mod inner {`
`294`	`288`	`}`
`295`	`289`
`296`	`290`	`pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {`
`297`		`- self.t.checked_add_duration(other).map(\|t\| Instant { t })`
	`291`	`+ Some(Instant { t: self.t.checked_add_duration(other)? })`
`298`	`292`	`}`
`299`	`293`
`300`		`- pub fn sub_duration(&self, other: &Duration) -> Instant {`
`301`		`- Instant { t: self.t.sub_duration(other) }`
	`294`	`+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {`
	`295`	`+ Some(Instant { t: self.t.checked_sub_duration(other)? })`
`302`	`296`	`}`
`303`	`297`	`}`
`304`	`298`
`@@ -322,11 +316,11 @@ mod inner {`
`322`	`316`	`}`
`323`	`317`
`324`	`318`	`pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`325`		`- self.t.checked_add_duration(other).map(\|t\| SystemTime { t })`
	`319`	`+ Some(SystemTime { t: self.t.checked_add_duration(other)? })`
`326`	`320`	`}`
`327`	`321`
`328`		`- pub fn sub_duration(&self, other: &Duration) -> SystemTime {`
`329`		`- SystemTime { t: self.t.sub_duration(other) }`
	`322`	`+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`323`	`+ Some(SystemTime { t: self.t.checked_sub_duration(other)? })`
`330`	`324`	`}`
`331`	`325`	`}`
`332`	`326`
Original file line number	Diff line number	Diff line change
`@@ -29,11 +29,11 @@ impl Instant {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {`
`32`		`- self.0.checked_add(*other).map(\|d\| Instant(d))`
	`32`	`+ Some(Instant(self.0.checked_add(*other)?))`
`33`	`33`	`}`
`34`	`34`
`35`		`- pub fn sub_duration(&self, other: &Duration) -> Instant {`
`36`		`- Instant(self.0 - *other)`
	`35`	`+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {`
	`36`	`+ Some(Instant(self.0.checked_sub(*other)?))`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`@@ -48,10 +48,10 @@ impl SystemTime {`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`51`		`- self.0.checked_add(*other).map(\|d\| SystemTime(d))`
	`51`	`+ Some(SystemTime(self.0.checked_add(*other)?))`
`52`	`52`	`}`
`53`	`53`
`54`		`- pub fn sub_duration(&self, other: &Duration) -> SystemTime {`
`55`		`- SystemTime(self.0 - *other)`
	`54`	`+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`55`	`+ Some(SystemTime(self.0.checked_sub(*other)?))`
`56`	`56`	`}`
`57`	`57`	`}`