1.0.0[−][src]Trait cron_clock::lib::std::ops::Sub
The subtraction operator -
.
Note that Rhs
is Self
by default, but this is not mandatory. For
example, std::time::SystemTime
implements Sub<Duration>
, which permits
operations of the form SystemTime = SystemTime - Duration
.
Examples
Sub
tractable points
use std::ops::Sub; #[derive(Debug, Copy, Clone, PartialEq)] struct Point { x: i32, y: i32, } impl Sub for Point { type Output = Point; fn sub(self, other: Point) -> Point { Point { x: self.x - other.x, y: self.y - other.y, } } } assert_eq!(Point { x: 3, y: 3 } - Point { x: 2, y: 3 }, Point { x: 1, y: 0 });
Implementing Sub
with generics
Here is an example of the same Point
struct implementing the Sub
trait
using generics.
use std::ops::Sub; #[derive(Debug, PartialEq)] struct Point<T> { x: T, y: T, } // Notice that the implementation uses the associated type `Output`. impl<T: Sub<Output = T>> Sub for Point<T> { type Output = Self; fn sub(self, other: Self) -> Self::Output { Point { x: self.x - other.x, y: self.y - other.y, } } } assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 }, Point { x: 1, y: 3 });
Associated Types
type Output
The resulting type after applying the -
operator.
Required methods
Loading content...Implementations on Foreign Types
impl Sub<Duration> for Instant
[src]
impl Sub<Instant> for Instant
[src]
impl Sub<Duration> for SystemTime
[src]
type Output = SystemTime
fn sub(self, dur: Duration) -> SystemTime
[src]
impl<'a> Sub<Wrapping<u128>> for &'a Wrapping<u128>
[src]
type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
fn sub(
self,
other: Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
[src]
self,
other: Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
impl Sub<i64> for i64
[src]
impl<'_> Sub<&'_ Wrapping<i32>> for Wrapping<i32>
[src]
type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
fn sub(
self,
other: &Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
[src]
self,
other: &Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
impl<'a> Sub<Wrapping<i32>> for &'a Wrapping<i32>
[src]
type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
fn sub(
self,
other: Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
[src]
self,
other: Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
impl<'_> Sub<&'_ Wrapping<u32>> for Wrapping<u32>
[src]
type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
fn sub(
self,
other: &Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
[src]
self,
other: &Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
impl<'a> Sub<u32> for &'a u32
[src]
impl<'_, '_> Sub<&'_ Wrapping<i16>> for &'_ Wrapping<i16>
[src]
type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
fn sub(
self,
other: &Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
[src]
self,
other: &Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
impl<'_, '_> Sub<&'_ i64> for &'_ i64
[src]
impl<'a> Sub<Wrapping<u16>> for &'a Wrapping<u16>
[src]
type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
fn sub(
self,
other: Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
[src]
self,
other: Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
impl Sub<u128> for u128
[src]
impl<'a> Sub<f64> for &'a f64
[src]
impl<'_> Sub<&'_ isize> for isize
[src]
type Output = <isize as Sub<isize>>::Output
fn sub(self, other: &isize) -> <isize as Sub<isize>>::Output
[src]
impl<'_, '_> Sub<&'_ u8> for &'_ u8
[src]
impl Sub<i32> for i32
[src]
impl<'_, '_> Sub<&'_ u16> for &'_ u16
[src]
impl Sub<Wrapping<i64>> for Wrapping<i64>
[src]
impl<'_, '_> Sub<&'_ isize> for &'_ isize
[src]
type Output = <isize as Sub<isize>>::Output
fn sub(self, other: &isize) -> <isize as Sub<isize>>::Output
[src]
impl<'_, '_> Sub<&'_ usize> for &'_ usize
[src]
type Output = <usize as Sub<usize>>::Output
fn sub(self, other: &usize) -> <usize as Sub<usize>>::Output
[src]
impl<'_, '_> Sub<&'_ Wrapping<usize>> for &'_ Wrapping<usize>
[src]
type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
fn sub(
self,
other: &Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
[src]
self,
other: &Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
impl<'a> Sub<i8> for &'a i8
[src]
impl Sub<f32> for f32
[src]
impl Sub<Wrapping<u16>> for Wrapping<u16>
[src]
impl Sub<f64> for f64
[src]
impl<'a> Sub<u64> for &'a u64
[src]
impl<'_, '_> Sub<&'_ Wrapping<u32>> for &'_ Wrapping<u32>
[src]
type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
fn sub(
self,
other: &Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
[src]
self,
other: &Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
impl<'_> Sub<&'_ u32> for u32
[src]
impl<'_, '_> Sub<&'_ Wrapping<i128>> for &'_ Wrapping<i128>
[src]
type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
fn sub(
self,
other: &Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
[src]
self,
other: &Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
impl<'a> Sub<Wrapping<u64>> for &'a Wrapping<u64>
[src]
type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
fn sub(
self,
other: Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
[src]
self,
other: Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
impl<'_, '_> Sub<&'_ i128> for &'_ i128
[src]
type Output = <i128 as Sub<i128>>::Output
fn sub(self, other: &i128) -> <i128 as Sub<i128>>::Output
[src]
impl Sub<Wrapping<u128>> for Wrapping<u128>
[src]
impl<'_> Sub<&'_ u8> for u8
[src]
impl<'_, '_> Sub<&'_ u128> for &'_ u128
[src]
type Output = <u128 as Sub<u128>>::Output
fn sub(self, other: &u128) -> <u128 as Sub<u128>>::Output
[src]
impl<'a> Sub<u8> for &'a u8
[src]
impl<'a> Sub<i64> for &'a i64
[src]
impl<'_, '_> Sub<&'_ Wrapping<i32>> for &'_ Wrapping<i32>
[src]
type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
fn sub(
self,
other: &Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
[src]
self,
other: &Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
impl Sub<i16> for i16
[src]
impl<'_, '_> Sub<&'_ i8> for &'_ i8
[src]
impl<'_, '_> Sub<&'_ f32> for &'_ f32
[src]
impl<'a> Sub<usize> for &'a usize
[src]
type Output = <usize as Sub<usize>>::Output
fn sub(self, other: usize) -> <usize as Sub<usize>>::Output
[src]
impl<'a> Sub<Wrapping<isize>> for &'a Wrapping<isize>
[src]
type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
fn sub(
self,
other: Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
[src]
self,
other: Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
impl Sub<u8> for u8
[src]
impl<'_, '_> Sub<&'_ Wrapping<u128>> for &'_ Wrapping<u128>
[src]
type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
fn sub(
self,
other: &Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
[src]
self,
other: &Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
impl<'a> Sub<u16> for &'a u16
[src]
impl<'_> Sub<&'_ i128> for i128
[src]
type Output = <i128 as Sub<i128>>::Output
fn sub(self, other: &i128) -> <i128 as Sub<i128>>::Output
[src]
impl<'_> Sub<&'_ Wrapping<u128>> for Wrapping<u128>
[src]
type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
fn sub(
self,
other: &Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
[src]
self,
other: &Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
impl<'a> Sub<Wrapping<u32>> for &'a Wrapping<u32>
[src]
type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
fn sub(
self,
other: Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
[src]
self,
other: Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
impl Sub<Duration> for Duration
[src]
impl Sub<Wrapping<u64>> for Wrapping<u64>
[src]
impl Sub<u64> for u64
[src]
impl<'_> Sub<&'_ Wrapping<u16>> for Wrapping<u16>
[src]
type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
fn sub(
self,
other: &Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
[src]
self,
other: &Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
impl<'_, '_> Sub<&'_ i16> for &'_ i16
[src]
impl<'a> Sub<f32> for &'a f32
[src]
impl<'_, '_> Sub<&'_ Wrapping<isize>> for &'_ Wrapping<isize>
[src]
type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
fn sub(
self,
other: &Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
[src]
self,
other: &Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
impl<'_, '_> Sub<&'_ Wrapping<u64>> for &'_ Wrapping<u64>
[src]
type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
fn sub(
self,
other: &Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
[src]
self,
other: &Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
impl<'_> Sub<&'_ Wrapping<i8>> for Wrapping<i8>
[src]
type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
fn sub(
self,
other: &Wrapping<i8>
) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
[src]
self,
other: &Wrapping<i8>
) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
impl Sub<i128> for i128
[src]
impl Sub<isize> for isize
[src]
impl<'_> Sub<&'_ f32> for f32
[src]
impl<'_, '_> Sub<&'_ u64> for &'_ u64
[src]
impl<'_> Sub<&'_ Wrapping<i16>> for Wrapping<i16>
[src]
type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
fn sub(
self,
other: &Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
[src]
self,
other: &Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
impl<'a> Sub<Wrapping<i8>> for &'a Wrapping<i8>
[src]
type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
fn sub(self, other: Wrapping<i8>) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
[src]
impl Sub<u16> for u16
[src]
impl<'_, '_> Sub<&'_ Wrapping<u16>> for &'_ Wrapping<u16>
[src]
type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
fn sub(
self,
other: &Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
[src]
self,
other: &Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
impl<'a> Sub<i16> for &'a i16
[src]
impl<'a> Sub<Wrapping<i64>> for &'a Wrapping<i64>
[src]
type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
fn sub(
self,
other: Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
[src]
self,
other: Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
impl<'_> Sub<&'_ Wrapping<isize>> for Wrapping<isize>
[src]
type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
fn sub(
self,
other: &Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
[src]
self,
other: &Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
impl Sub<Wrapping<i8>> for Wrapping<i8>
[src]
impl<'_> Sub<&'_ i8> for i8
[src]
impl<'_> Sub<&'_ f64> for f64
[src]
impl Sub<Wrapping<u32>> for Wrapping<u32>
[src]
impl<'a> Sub<Wrapping<i128>> for &'a Wrapping<i128>
[src]
type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
fn sub(
self,
other: Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
[src]
self,
other: Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
impl<'a> Sub<Wrapping<usize>> for &'a Wrapping<usize>
[src]
type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
fn sub(
self,
other: Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
[src]
self,
other: Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
impl<'_> Sub<&'_ Wrapping<u64>> for Wrapping<u64>
[src]
type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
fn sub(
self,
other: &Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
[src]
self,
other: &Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
impl<'_> Sub<&'_ u128> for u128
[src]
type Output = <u128 as Sub<u128>>::Output
fn sub(self, other: &u128) -> <u128 as Sub<u128>>::Output
[src]
impl Sub<i8> for i8
[src]
impl<'_, '_> Sub<&'_ Wrapping<i64>> for &'_ Wrapping<i64>
[src]
type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
fn sub(
self,
other: &Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
[src]
self,
other: &Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
impl<'_, '_> Sub<&'_ f64> for &'_ f64
[src]
impl<'_> Sub<&'_ Wrapping<i128>> for Wrapping<i128>
[src]
type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
fn sub(
self,
other: &Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
[src]
self,
other: &Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
impl<'_, '_> Sub<&'_ Wrapping<u8>> for &'_ Wrapping<u8>
[src]
type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
fn sub(
self,
other: &Wrapping<u8>
) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
[src]
self,
other: &Wrapping<u8>
) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
impl<'_> Sub<&'_ Wrapping<u8>> for Wrapping<u8>
[src]
type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
fn sub(
self,
other: &Wrapping<u8>
) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
[src]
self,
other: &Wrapping<u8>
) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
impl Sub<Wrapping<u8>> for Wrapping<u8>
[src]
impl<'_> Sub<&'_ u64> for u64
[src]
impl<'a> Sub<u128> for &'a u128
[src]
type Output = <u128 as Sub<u128>>::Output
fn sub(self, other: u128) -> <u128 as Sub<u128>>::Output
[src]
impl Sub<u32> for u32
[src]
impl Sub<Wrapping<i16>> for Wrapping<i16>
[src]
impl<'_, '_> Sub<&'_ i32> for &'_ i32
[src]
impl Sub<Wrapping<i32>> for Wrapping<i32>
[src]
impl Sub<Wrapping<i128>> for Wrapping<i128>
[src]
impl<'a> Sub<Wrapping<i16>> for &'a Wrapping<i16>
[src]
type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
fn sub(
self,
other: Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
[src]
self,
other: Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
impl<'_> Sub<&'_ i64> for i64
[src]
impl Sub<usize> for usize
[src]
impl<'_> Sub<&'_ i32> for i32
[src]
impl<'_> Sub<&'_ u16> for u16
[src]
impl<'_> Sub<&'_ Wrapping<i64>> for Wrapping<i64>
[src]
type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
fn sub(
self,
other: &Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
[src]
self,
other: &Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
impl<'a> Sub<i128> for &'a i128
[src]
type Output = <i128 as Sub<i128>>::Output
fn sub(self, other: i128) -> <i128 as Sub<i128>>::Output
[src]
impl<'a> Sub<isize> for &'a isize
[src]
type Output = <isize as Sub<isize>>::Output
fn sub(self, other: isize) -> <isize as Sub<isize>>::Output
[src]
impl<'a> Sub<i32> for &'a i32
[src]
impl<'_, '_> Sub<&'_ u32> for &'_ u32
[src]
impl<'_> Sub<&'_ Wrapping<usize>> for Wrapping<usize>
[src]
type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
fn sub(
self,
other: &Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
[src]
self,
other: &Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
impl<'_> Sub<&'_ usize> for usize
[src]
type Output = <usize as Sub<usize>>::Output
fn sub(self, other: &usize) -> <usize as Sub<usize>>::Output
[src]
impl<'_> Sub<&'_ i16> for i16
[src]
impl Sub<Wrapping<isize>> for Wrapping<isize>
[src]
impl<'_, '_> Sub<&'_ Wrapping<i8>> for &'_ Wrapping<i8>
[src]
type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
fn sub(
self,
other: &Wrapping<i8>
) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
[src]
self,
other: &Wrapping<i8>
) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
impl<'a> Sub<Wrapping<u8>> for &'a Wrapping<u8>
[src]
type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
fn sub(self, other: Wrapping<u8>) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
[src]
impl Sub<Wrapping<usize>> for Wrapping<usize>
[src]
impl<'_, '_, T, S> Sub<&'_ HashSet<T, S>> for &'_ HashSet<T, S> where
S: BuildHasher + Default,
T: Eq + Hash + Clone,
S: BuildHasher + Default,
T: Eq + Hash + Clone,
type Output = HashSet<T, S>
fn sub(self, rhs: &HashSet<T, S>) -> HashSet<T, S>
Returns the difference of self
and rhs
as a new HashSet<T, S>
.
Examples
use hashbrown::HashSet; let a: HashSet<_> = vec![1, 2, 3].into_iter().collect(); let b: HashSet<_> = vec![3, 4, 5].into_iter().collect(); let set = &a - &b; let mut i = 0; let expected = [1, 2]; for x in &set { assert!(expected.contains(x)); i += 1; } assert_eq!(i, expected.len());
impl Sub<Duration> for Timespec
[src]
impl Sub<Tm> for Tm
[src]
impl Sub<Duration> for Tm
[src]
impl Sub<SteadyTime> for SteadyTime
[src]
impl Sub<Timespec> for Timespec
[src]
impl Sub<Duration> for SteadyTime
[src]
type Output = SteadyTime
fn sub(self, other: Duration) -> SteadyTime
[src]
Implementors
impl Sub<Duration> for cron_clock::Duration
[src]
impl Sub<Duration> for NaiveDate
[src]
A subtraction of Duration
from NaiveDate
discards the fractional days,
rounding to the closest integral number of days towards Duration::zero()
.
It is the same as the addition with a negated Duration
.
Panics on underflow or overflow.
Use NaiveDate::checked_sub_signed
to detect that.
Example
use chrono::NaiveDate; use time::Duration; let from_ymd = NaiveDate::from_ymd; assert_eq!(from_ymd(2014, 1, 1) - Duration::zero(), from_ymd(2014, 1, 1)); assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(86399), from_ymd(2014, 1, 1)); assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(-86399), from_ymd(2014, 1, 1)); assert_eq!(from_ymd(2014, 1, 1) - Duration::days(1), from_ymd(2013, 12, 31)); assert_eq!(from_ymd(2014, 1, 1) - Duration::days(-1), from_ymd(2014, 1, 2)); assert_eq!(from_ymd(2014, 1, 1) - Duration::days(364), from_ymd(2013, 1, 2)); assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*4 + 1), from_ymd(2010, 1, 1)); assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*400 + 97), from_ymd(1614, 1, 1));
impl Sub<Duration> for NaiveDateTime
[src]
A subtraction of Duration
from NaiveDateTime
yields another NaiveDateTime
.
It is the same as the addition with a negated Duration
.
As a part of Chrono's leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveDateTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
Panics on underflow or overflow.
Use NaiveDateTime::checked_sub_signed
to detect that.
Example
use chrono::NaiveDate; use time::Duration; let from_ymd = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); let hms = |h, m, s| d.and_hms(h, m, s); assert_eq!(hms(3, 5, 7) - Duration::zero(), hms(3, 5, 7)); assert_eq!(hms(3, 5, 7) - Duration::seconds(1), hms(3, 5, 6)); assert_eq!(hms(3, 5, 7) - Duration::seconds(-1), hms(3, 5, 8)); assert_eq!(hms(3, 5, 7) - Duration::seconds(3600 + 60), hms(2, 4, 7)); assert_eq!(hms(3, 5, 7) - Duration::seconds(86_400), from_ymd(2016, 7, 7).and_hms(3, 5, 7)); assert_eq!(hms(3, 5, 7) - Duration::days(365), from_ymd(2015, 7, 9).and_hms(3, 5, 7)); let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli); assert_eq!(hmsm(3, 5, 7, 450) - Duration::milliseconds(670), hmsm(3, 5, 6, 780));
Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300); assert_eq!(leap - Duration::zero(), hmsm(3, 5, 59, 1_300)); assert_eq!(leap - Duration::milliseconds(200), hmsm(3, 5, 59, 1_100)); assert_eq!(leap - Duration::milliseconds(500), hmsm(3, 5, 59, 800)); assert_eq!(leap - Duration::seconds(60), hmsm(3, 5, 0, 300)); assert_eq!(leap - Duration::days(1), from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300));
type Output = NaiveDateTime
fn sub(self, rhs: Duration) -> NaiveDateTime
[src]
impl Sub<Duration> for NaiveTime
[src]
A subtraction of Duration
from NaiveTime
wraps around and never overflows or underflows.
In particular the addition ignores integral number of days.
It is the same as the addition with a negated Duration
.
As a part of Chrono's leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
Example
use chrono::NaiveTime; use time::Duration; let from_hmsm = NaiveTime::from_hms_milli; assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::zero(), from_hmsm(3, 5, 7, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(1), from_hmsm(3, 5, 6, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(60 + 5), from_hmsm(3, 4, 2, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(2*60*60 + 6*60), from_hmsm(0, 59, 7, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::milliseconds(80), from_hmsm(3, 5, 6, 920)); assert_eq!(from_hmsm(3, 5, 7, 950) - Duration::milliseconds(280), from_hmsm(3, 5, 7, 670));
The subtraction wraps around.
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(8*60*60), from_hmsm(19, 5, 7, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::days(800), from_hmsm(3, 5, 7, 0));
Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.
let leap = from_hmsm(3, 5, 59, 1_300); assert_eq!(leap - Duration::zero(), from_hmsm(3, 5, 59, 1_300)); assert_eq!(leap - Duration::milliseconds(200), from_hmsm(3, 5, 59, 1_100)); assert_eq!(leap - Duration::milliseconds(500), from_hmsm(3, 5, 59, 800)); assert_eq!(leap - Duration::seconds(60), from_hmsm(3, 5, 0, 300)); assert_eq!(leap - Duration::days(1), from_hmsm(3, 6, 0, 300));
impl Sub<FixedOffset> for NaiveDateTime
[src]
type Output = NaiveDateTime
fn sub(self, rhs: FixedOffset) -> NaiveDateTime
[src]
impl Sub<FixedOffset> for NaiveTime
[src]
impl Sub<NaiveDate> for NaiveDate
[src]
Subtracts another NaiveDate
from the current date.
Returns a Duration
of integral numbers.
This does not overflow or underflow at all,
as all possible output fits in the range of Duration
.
The implementation is a wrapper around
NaiveDate::signed_duration_since
.
Example
use chrono::NaiveDate; use time::Duration; let from_ymd = NaiveDate::from_ymd; assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 1), Duration::zero()); assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 12, 31), Duration::days(1)); assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 2), Duration::days(-1)); assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 9, 23), Duration::days(100)); assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 1, 1), Duration::days(365)); assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2010, 1, 1), Duration::days(365*4 + 1)); assert_eq!(from_ymd(2014, 1, 1) - from_ymd(1614, 1, 1), Duration::days(365*400 + 97));
impl Sub<NaiveDateTime> for NaiveDateTime
[src]
Subtracts another NaiveDateTime
from the current date and time.
This does not overflow or underflow at all.
As a part of Chrono's leap second handling,
the subtraction assumes that there is no leap second ever,
except when any of the NaiveDateTime
s themselves represents a leap second
in which case the assumption becomes that
there are exactly one (or two) leap second(s) ever.
The implementation is a wrapper around
NaiveDateTime::signed_duration_since
.
Example
use chrono::NaiveDate; use time::Duration; let from_ymd = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); assert_eq!(d.and_hms(3, 5, 7) - d.and_hms(2, 4, 6), Duration::seconds(3600 + 60 + 1)); // July 8 is 190th day in the year 2016 let d0 = from_ymd(2016, 1, 1); assert_eq!(d.and_hms_milli(0, 7, 6, 500) - d0.and_hms(0, 0, 0), Duration::seconds(189 * 86_400 + 7 * 60 + 6) + Duration::milliseconds(500));
Leap seconds are handled, but the subtraction assumes that there were no other leap seconds happened.
let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500); assert_eq!(leap - from_ymd(2015, 6, 30).and_hms(23, 0, 0), Duration::seconds(3600) + Duration::milliseconds(500)); assert_eq!(from_ymd(2015, 7, 1).and_hms(1, 0, 0) - leap, Duration::seconds(3600) - Duration::milliseconds(500));
impl Sub<NaiveTime> for NaiveTime
[src]
Subtracts another NaiveTime
from the current time.
Returns a Duration
within +/- 1 day.
This does not overflow or underflow at all.
As a part of Chrono's leap second handling,
the subtraction assumes that there is no leap second ever,
except when any of the NaiveTime
s themselves represents a leap second
in which case the assumption becomes that
there are exactly one (or two) leap second(s) ever.
The implementation is a wrapper around
NaiveTime::signed_duration_since
.
Example
use chrono::NaiveTime; use time::Duration; let from_hmsm = NaiveTime::from_hms_milli; assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 7, 900), Duration::zero()); assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 7, 875), Duration::milliseconds(25)); assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 6, 925), Duration::milliseconds(975)); assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 0, 900), Duration::seconds(7)); assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 0, 7, 900), Duration::seconds(5 * 60)); assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(0, 5, 7, 900), Duration::seconds(3 * 3600)); assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(4, 5, 7, 900), Duration::seconds(-3600)); assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(2, 4, 6, 800), Duration::seconds(3600 + 60 + 1) + Duration::milliseconds(100));
Leap seconds are handled, but the subtraction assumes that there were no other leap seconds happened.
assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 59, 0), Duration::seconds(1)); assert_eq!(from_hmsm(3, 0, 59, 1_500) - from_hmsm(3, 0, 59, 0), Duration::milliseconds(1500)); assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 0, 0), Duration::seconds(60)); assert_eq!(from_hmsm(3, 0, 0, 0) - from_hmsm(2, 59, 59, 1_000), Duration::seconds(1)); assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(2, 59, 59, 1_000), Duration::seconds(61));
impl<'_, '_, T> Sub<&'_ BTreeSet<T>> for &'_ BTreeSet<T> where
T: Clone + Ord,
[src]
T: Clone + Ord,
type Output = BTreeSet<T>
fn sub(self, rhs: &BTreeSet<T>) -> BTreeSet<T>
[src]
Returns the difference of self
and rhs
as a new BTreeSet<T>
.
Examples
use std::collections::BTreeSet; let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect(); let result = &a - &b; let result_vec: Vec<_> = result.into_iter().collect(); assert_eq!(result_vec, [1, 2]);
impl<'_, '_, T, S> Sub<&'_ HashSet<T, S>> for &'_ cron_clock::lib::std::collections::HashSet<T, S> where
S: BuildHasher + Default,
T: Eq + Hash + Clone,
[src]
S: BuildHasher + Default,
T: Eq + Hash + Clone,
type Output = HashSet<T, S>
fn sub(self, rhs: &HashSet<T, S>) -> HashSet<T, S>
[src]
Returns the difference of self
and rhs
as a new HashSet<T, S>
.
Examples
use std::collections::HashSet; let a: HashSet<_> = vec![1, 2, 3].into_iter().collect(); let b: HashSet<_> = vec![3, 4, 5].into_iter().collect(); let set = &a - &b; let mut i = 0; let expected = [1, 2]; for x in &set { assert!(expected.contains(x)); i += 1; } assert_eq!(i, expected.len());
impl<Tz> Sub<Date<Tz>> for Date<Tz> where
Tz: TimeZone,
[src]
Tz: TimeZone,
impl<Tz> Sub<DateTime<Tz>> for DateTime<Tz> where
Tz: TimeZone,
[src]
Tz: TimeZone,
impl<Tz> Sub<Duration> for Date<Tz> where
Tz: TimeZone,
[src]
Tz: TimeZone,
impl<Tz> Sub<Duration> for DateTime<Tz> where
Tz: TimeZone,
[src]
Tz: TimeZone,
impl<Tz> Sub<FixedOffset> for DateTime<Tz> where
Tz: TimeZone,
[src]
Tz: TimeZone,