1.0.0[−][src]Trait geng_core::prelude::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 = Self; fn sub(self, other: Self) -> Self::Output { Self { 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 SystemTime
[src]
type Output = SystemTime
fn sub(self, dur: Duration) -> SystemTime
[src]
impl Sub<Duration> for Instant
[src]
impl Sub<Instant> for Instant
[src]
impl Sub<usize> for usize
[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 Sub<f64> for f64
[src]
impl Sub<Duration> for Duration
[src]
impl Sub<f32> for f32
[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<'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<&'_ u64> for u64
[src]
impl<'_, '_> Sub<&'_ u64> for &'_ u64
[src]
impl Sub<i128> for i128
[src]
impl Sub<Wrapping<u128>> for Wrapping<u128>
[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<&'_ 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<&'_ 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<'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 Sub<i8> for i8
[src]
impl Sub<Wrapping<u8>> for Wrapping<u8>
[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<&'_ f32> for &'_ f32
[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<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<&'_ u32> for u32
[src]
impl Sub<i32> for i32
[src]
impl<'_, '_> Sub<&'_ u32> for &'_ u32
[src]
impl<'_, '_> Sub<&'_ i32> for &'_ i32
[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<&'_ i64> for i64
[src]
impl Sub<Wrapping<u32>> for Wrapping<u32>
[src]
impl Sub<Wrapping<i64>> for Wrapping<i64>
[src]
impl Sub<u16> for u16
[src]
impl<'a> Sub<i32> for &'a i32
[src]
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<'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<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<&'_ 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<Wrapping<i8>> for Wrapping<i8>
[src]
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<'_> 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<'a> Sub<u16> for &'a u16
[src]
impl<'_> Sub<&'_ i8> for i8
[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<'_, '_> 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<Wrapping<u16>> for Wrapping<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<&'_ i64> for &'_ i64
[src]
impl Sub<i64> for i64
[src]
impl<'_> Sub<&'_ i32> for i32
[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<&'_ u16> for u16
[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<isize> for isize
[src]
impl<'a> Sub<f32> for &'a f32
[src]
impl<'a> Sub<u8> for &'a u8
[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<'a> Sub<f64> for &'a f64
[src]
impl<'a> Sub<u32> for &'a u32
[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]
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<'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<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<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<u128> for u128
[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<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<&'_ 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<i128> for &'a i128
[src]
type Output = <i128 as Sub<i128>>::Output
fn sub(self, other: i128) -> <i128 as Sub<i128>>::Output
[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<&'_ 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<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<Wrapping<i32>> for Wrapping<i32>
[src]
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<&'_ u8> for u8
[src]
impl Sub<Wrapping<i16>> for Wrapping<i16>
[src]
impl<'_> Sub<&'_ f64> for f64
[src]
impl<'a> Sub<i16> for &'a i16
[src]
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<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<&'_ u16> for &'_ u16
[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<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<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<'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<'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<u64> for u64
[src]
impl<'_, '_> Sub<&'_ i16> for &'_ i16
[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<&'_ u8> for &'_ u8
[src]
impl Sub<i16> for i16
[src]
impl Sub<Wrapping<isize>> for Wrapping<isize>
[src]
impl<'a> Sub<i8> for &'a i8
[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<usize>> for Wrapping<usize>
[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<Wrapping<i128>> for Wrapping<i128>
[src]
impl<'a> Sub<i64> for &'a i64
[src]
impl<'a> Sub<u64> for &'a u64
[src]
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<u32> for u32
[src]
impl<'_, '_> Sub<&'_ i8> for &'_ i8
[src]
impl<'_> Sub<&'_ f32> for f32
[src]
impl<'_> Sub<&'_ i16> for i16
[src]
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 Sub<Extensions> for Extensions
[src]
type Output = Extensions
fn sub(self, other: Extensions) -> Extensions
[src]
Returns the set difference of the two sets of flags.
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::{Duration, NaiveDate}; 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<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,
impl<Tz> Sub<Duration> for Date<Tz> where
Tz: TimeZone,
[src]
Tz: TimeZone,
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::{Duration, NaiveDate}; 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<Tz> Sub<DateTime<Tz>> for DateTime<Tz> where
Tz: TimeZone,
[src]
Tz: TimeZone,
impl Sub<FixedOffset> for NaiveTime
[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::{Duration, NaiveTime}; 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<Tz> Sub<Date<Tz>> for Date<Tz> where
Tz: TimeZone,
[src]
Tz: TimeZone,
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::{Duration, NaiveDate}; 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<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::{Duration, NaiveDate}; 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<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::{Duration, NaiveTime}; 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 Sub<Tm> for Tm
[src]
impl Sub<Duration> for Duration
[src]
impl Sub<SteadyTime> for SteadyTime
[src]
impl Sub<Timespec> for Timespec
[src]
impl Sub<Duration> for Tm
[src]
impl Sub<Duration> for SteadyTime
[src]
type Output = SteadyTime
fn sub(self, other: Duration) -> SteadyTime
[src]
impl Sub<Duration> for Timespec
[src]
impl Sub<ModifiersState> for ModifiersState
[src]
type Output = ModifiersState
fn sub(self, other: ModifiersState) -> ModifiersState
[src]
Returns the set difference of the two sets of flags.
impl Sub<Sides> for Sides
[src]
type Output = Sides
fn sub(self, other: Sides) -> Sides
[src]
Returns the set difference of the two sets of flags.
impl<N> Sub<Point<N>> for Point<N> where
N: Sub<N, Output = N>,
[src]
N: Sub<N, Output = N>,
impl<N> Sub<Vector<N>> for Vector<N> where
N: Sub<N, Output = N>,
[src]
N: Sub<N, Output = N>,
impl<N> Sub<Vector<N>> for Point<N> where
N: Sub<N, Output = N>,
[src]
N: Sub<N, Output = N>,
impl<T> Sub<OrderedFloat<T>> for OrderedFloat<T> where
T: FloatCore,
T: FloatCore,
impl<T> Sub<NotNan<T>> for NotNan<T> where
T: FloatCore,
T: FloatCore,
impl<T> Sub<T> for NotNan<T> where
T: FloatCore,
T: FloatCore,
Subtracts a float directly.
Panics if the provided value is NaN or the computation results in NaN
impl Sub<MsFlags> for MsFlags
[src]
type Output = MsFlags
fn sub(self, other: MsFlags) -> MsFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<Mode> for Mode
[src]
type Output = Mode
fn sub(self, other: Mode) -> Mode
[src]
Returns the set difference of the two sets of flags.
impl Sub<SaFlags> for SaFlags
[src]
type Output = SaFlags
fn sub(self, other: SaFlags) -> SaFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<AddWatchFlags> for AddWatchFlags
[src]
type Output = AddWatchFlags
fn sub(self, other: AddWatchFlags) -> AddWatchFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<OutputFlags> for OutputFlags
[src]
type Output = OutputFlags
fn sub(self, other: OutputFlags) -> OutputFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<MntFlags> for MntFlags
[src]
type Output = MntFlags
fn sub(self, other: MntFlags) -> MntFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<SealFlag> for SealFlag
[src]
type Output = SealFlag
fn sub(self, other: SealFlag) -> SealFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<InitFlags> for InitFlags
[src]
type Output = InitFlags
fn sub(self, other: InitFlags) -> InitFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<SockFlag> for SockFlag
[src]
type Output = SockFlag
fn sub(self, other: SockFlag) -> SockFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<ControlFlags> for ControlFlags
[src]
type Output = ControlFlags
fn sub(self, other: ControlFlags) -> ControlFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<TimeSpec> for TimeSpec
impl Sub<ProtFlags> for ProtFlags
[src]
type Output = ProtFlags
fn sub(self, other: ProtFlags) -> ProtFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<ModuleInitFlags> for ModuleInitFlags
[src]
type Output = ModuleInitFlags
fn sub(self, other: ModuleInitFlags) -> ModuleInitFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<SfdFlags> for SfdFlags
[src]
type Output = SfdFlags
fn sub(self, other: SfdFlags) -> SfdFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<MapFlags> for MapFlags
[src]
type Output = MapFlags
fn sub(self, other: MapFlags) -> MapFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<TimeVal> for TimeVal
impl Sub<SFlag> for SFlag
[src]
type Output = SFlag
fn sub(self, other: SFlag) -> SFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<EfdFlags> for EfdFlags
[src]
type Output = EfdFlags
fn sub(self, other: EfdFlags) -> EfdFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<DeleteModuleFlags> for DeleteModuleFlags
[src]
type Output = DeleteModuleFlags
fn sub(self, other: DeleteModuleFlags) -> DeleteModuleFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<MsgFlags> for MsgFlags
[src]
type Output = MsgFlags
fn sub(self, other: MsgFlags) -> MsgFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<PollFlags> for PollFlags
[src]
type Output = PollFlags
fn sub(self, other: PollFlags) -> PollFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<WaitPidFlag> for WaitPidFlag
[src]
type Output = WaitPidFlag
fn sub(self, other: WaitPidFlag) -> WaitPidFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<EpollFlags> for EpollFlags
[src]
type Output = EpollFlags
fn sub(self, other: EpollFlags) -> EpollFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<LocalFlags> for LocalFlags
[src]
type Output = LocalFlags
fn sub(self, other: LocalFlags) -> LocalFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<AccessFlags> for AccessFlags
[src]
type Output = AccessFlags
fn sub(self, other: AccessFlags) -> AccessFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<OFlag> for OFlag
[src]
type Output = OFlag
fn sub(self, other: OFlag) -> OFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<InterfaceFlags> for InterfaceFlags
[src]
type Output = InterfaceFlags
fn sub(self, other: InterfaceFlags) -> InterfaceFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<AtFlags> for AtFlags
[src]
type Output = AtFlags
fn sub(self, other: AtFlags) -> AtFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<Options> for Options
[src]
type Output = Options
fn sub(self, other: Options) -> Options
[src]
Returns the set difference of the two sets of flags.
impl Sub<QuotaValidFlags> for QuotaValidFlags
[src]
type Output = QuotaValidFlags
fn sub(self, other: QuotaValidFlags) -> QuotaValidFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<InputFlags> for InputFlags
[src]
type Output = InputFlags
fn sub(self, other: InputFlags) -> InputFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<EpollCreateFlags> for EpollCreateFlags
[src]
type Output = EpollCreateFlags
fn sub(self, other: EpollCreateFlags) -> EpollCreateFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<FdFlag> for FdFlag
[src]
type Output = FdFlag
fn sub(self, other: FdFlag) -> FdFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<FdFlag> for FdFlag
[src]
type Output = FdFlag
fn sub(self, other: FdFlag) -> FdFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<CloneFlags> for CloneFlags
[src]
type Output = CloneFlags
fn sub(self, other: CloneFlags) -> CloneFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<MemFdCreateFlag> for MemFdCreateFlag
[src]
type Output = MemFdCreateFlag
fn sub(self, other: MemFdCreateFlag) -> MemFdCreateFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<MsFlags> for MsFlags
[src]
type Output = MsFlags
fn sub(self, other: MsFlags) -> MsFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<MlockAllFlags> for MlockAllFlags
[src]
type Output = MlockAllFlags
fn sub(self, other: MlockAllFlags) -> MlockAllFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<SpliceFFlags> for SpliceFFlags
[src]
type Output = SpliceFFlags
fn sub(self, other: SpliceFFlags) -> SpliceFFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<MQ_OFlag> for MQ_OFlag
[src]
type Output = MQ_OFlag
fn sub(self, other: MQ_OFlag) -> MQ_OFlag
[src]
Returns the set difference of the two sets of flags.
impl Sub<FallocateFlags> for FallocateFlags
[src]
type Output = FallocateFlags
fn sub(self, other: FallocateFlags) -> FallocateFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<FsFlags> for FsFlags
[src]
type Output = FsFlags
fn sub(self, other: FsFlags) -> FsFlags
[src]
Returns the set difference of the two sets of flags.
impl Sub<Transient> for Transient
[src]
type Output = Transient
fn sub(self, other: Transient) -> Transient
[src]
Returns the set difference of the two sets of flags.
impl Sub<DndAction> for DndAction
[src]
type Output = DndAction
fn sub(self, other: DndAction) -> DndAction
[src]
Returns the set difference of the two sets of flags.
impl Sub<Resize> for Resize
[src]
type Output = Resize
fn sub(self, other: Resize) -> Resize
[src]
Returns the set difference of the two sets of flags.
impl Sub<Mode> for Mode
[src]
type Output = Mode
fn sub(self, other: Mode) -> Mode
[src]
Returns the set difference of the two sets of flags.
impl Sub<Capability> for Capability
[src]
type Output = Capability
fn sub(self, other: Capability) -> Capability
[src]
Returns the set difference of the two sets of flags.
impl Sub<PollOpt> for PollOpt
[src]
impl<T> Sub<T> for Ready where
T: Into<Ready>,
[src]
T: Into<Ready>,
impl Sub<UnixReady> for UnixReady
[src]
impl Sub<Anchor> for Anchor
[src]
type Output = Anchor
fn sub(self, other: Anchor) -> Anchor
[src]
Returns the set difference of the two sets of flags.
impl Sub<ConstraintAdjustment> for ConstraintAdjustment
[src]
type Output = ConstraintAdjustment
fn sub(self, other: ConstraintAdjustment) -> ConstraintAdjustment
[src]
Returns the set difference of the two sets of flags.
impl Sub<Anchor> for Anchor
[src]
type Output = Anchor
fn sub(self, other: Anchor) -> Anchor
[src]
Returns the set difference of the two sets of flags.
impl Sub<Gravity> for Gravity
[src]
type Output = Gravity
fn sub(self, other: Gravity) -> Gravity
[src]
Returns the set difference of the two sets of flags.
impl Sub<ContentHint> for ContentHint
[src]
type Output = ContentHint
fn sub(self, other: ContentHint) -> ContentHint
[src]
Returns the set difference of the two sets of flags.
impl Sub<Flags> for Flags
[src]
type Output = Flags
fn sub(self, other: Flags) -> Flags
[src]
Returns the set difference of the two sets of flags.
impl Sub<ConstraintAdjustment> for ConstraintAdjustment
[src]
type Output = ConstraintAdjustment
fn sub(self, other: ConstraintAdjustment) -> ConstraintAdjustment
[src]
Returns the set difference of the two sets of flags.
impl<'a, 'b, T> Sub<&'b Ratio<T>> for &'a Ratio<T> where
T: Clone + Integer,
[src]
T: Clone + Integer,
impl<T> Sub<Ratio<T>> for Ratio<T> where
T: Clone + Integer,
[src]
T: Clone + Integer,
impl<'a, T> Sub<Ratio<T>> for &'a Ratio<T> where
T: Clone + Integer,
[src]
T: Clone + Integer,
impl<'a, T> Sub<&'a T> for Ratio<T> where
T: Clone + Integer,
[src]
T: Clone + Integer,
impl<T> Sub<T> for Ratio<T> where
T: Clone + Integer,
[src]
T: Clone + Integer,
impl<'a, 'b, T> Sub<&'b T> for &'a Ratio<T> where
T: Clone + Integer,
[src]
T: Clone + Integer,
impl<'a, T> Sub<T> for &'a Ratio<T> where
T: Clone + Integer,
[src]
T: Clone + Integer,
impl<'a, T> Sub<&'a Ratio<T>> for Ratio<T> where
T: Clone + Integer,
[src]
T: Clone + Integer,
impl Sub<Transformations> for Transformations
[src]
type Output = Transformations
fn sub(self, other: Transformations) -> Transformations
[src]
Returns the set difference of the two sets of flags.
impl<N> Sub<Vector<N>> for Vector<N> where
N: Sub<N, Output = N>,
[src]
N: Sub<N, Output = N>,
impl<N> Sub<Vector<N>> for Point<N> where
N: Sub<N, Output = N>,
[src]
N: Sub<N, Output = N>,
impl<N> Sub<Point<N>> for Point<N> where
N: Sub<N, Output = N>,
[src]
N: Sub<N, Output = N>,
impl Sub<Point> for Point
type Output = Point
fn sub(self, rhs: Point) -> Point
Subtract rhs.x from x, rhs.y from y.
let p1 = point(1.0, 2.0) - point(2.0, 1.5); assert!((p1.x - -1.0).abs() <= core::f32::EPSILON); assert!((p1.y - 0.5).abs() <= core::f32::EPSILON);
impl Sub<Op> for Op
[src]
type Output = Op
fn sub(self, other: Op) -> Op
[src]
Returns the set difference of the two sets of flags.
impl Sub<WatchMask> for WatchMask
[src]
type Output = WatchMask
fn sub(self, other: WatchMask) -> WatchMask
[src]
Returns the set difference of the two sets of flags.
impl Sub<EventMask> for EventMask
[src]
type Output = EventMask
fn sub(self, other: EventMask) -> EventMask
[src]
Returns the set difference of the two sets of flags.
Implementors
impl<'_, '_, T, S> Sub<&'_ HashSet<T, S>> for &'_ 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<T> Sub<Mat4<T>> for Mat4<T> where
T: Num + Copy,
[src]
T: Num + Copy,
impl<T> Sub<RealImpl<T>> for RealImpl<T> where
T: Float,
[src]
T: Float,
impl<T> Sub<Vec2<T>> for Vec2<T> where
T: Sub<T, Output = T>,
[src]
T: Sub<T, Output = T>,
impl<T> Sub<Vec3<T>> for Vec3<T> where
T: Sub<T, Output = T>,
[src]
T: Sub<T, Output = T>,
impl<T> Sub<Vec4<T>> for Vec4<T> where
T: Sub<T, Output = T>,
[src]
T: Sub<T, Output = T>,