1.0.0[−][src]Trait af_lib::prelude::af_core::test::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
Subtractable 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
Loading content...Required methods
Loading content...Implementations on Foreign Types
impl Sub<Instant> for Instant[src]
impl Sub<Duration> for Instant[src]
impl Sub<Duration> for SystemTime[src]
type Output = SystemTime
pub fn sub(self, dur: Duration) -> SystemTime[src]
impl<'_, '_, T, S> Sub<&'_ HashSet<T, S>> for &'_ HashSet<T, S> where
T: Eq + Hash + Clone,
S: BuildHasher + Default, [src]
T: Eq + Hash + Clone,
S: BuildHasher + Default,
type Output = HashSet<T, S>
pub 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<'a> Sub<i32> for &'a i32[src]
type Output = <i32 as Sub<i32>>::Output
pub fn sub(self, other: i32) -> <i32 as Sub<i32>>::Output[src]
impl<'a> Sub<Wrapping<i16>> for &'a Wrapping<i16>[src]
type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
pub 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<f64> for f64[src]
impl<'_> Sub<&'_ u16> for u16[src]
type Output = <u16 as Sub<u16>>::Output
pub fn sub(self, other: &u16) -> <u16 as Sub<u16>>::Output[src]
impl<'_> Sub<&'_ u64> for u64[src]
type Output = <u64 as Sub<u64>>::Output
pub fn sub(self, other: &u64) -> <u64 as Sub<u64>>::Output[src]
impl Sub<Wrapping<i32>> for Wrapping<i32>[src]
impl<'_> Sub<&'_ Wrapping<i128>> for Wrapping<i128>[src]
type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
pub 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<&'_ u64> for &'_ u64[src]
type Output = <u64 as Sub<u64>>::Output
pub fn sub(self, other: &u64) -> <u64 as Sub<u64>>::Output[src]
impl<'_, '_> Sub<&'_ i128> for &'_ i128[src]
type Output = <i128 as Sub<i128>>::Output
pub fn sub(self, other: &i128) -> <i128 as Sub<i128>>::Output[src]
impl<'_> Sub<&'_ i128> for i128[src]
type Output = <i128 as Sub<i128>>::Output
pub fn sub(self, other: &i128) -> <i128 as Sub<i128>>::Output[src]
impl<'_, '_> Sub<&'_ Wrapping<i32>> for &'_ Wrapping<i32>[src]
type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
pub 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
pub 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<u16>> for &'_ Wrapping<u16>[src]
type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
pub 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<&'_ isize> for &'_ isize[src]
type Output = <isize as Sub<isize>>::Output
pub fn sub(self, other: &isize) -> <isize as Sub<isize>>::Output[src]
impl<'_> Sub<&'_ Wrapping<u32>> for Wrapping<u32>[src]
type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
pub 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<Wrapping<u16>> for &'a Wrapping<u16>[src]
type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
pub 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<usize>> for Wrapping<usize>[src]
impl<'_> Sub<&'_ usize> for usize[src]
type Output = <usize as Sub<usize>>::Output
pub fn sub(self, other: &usize) -> <usize as Sub<usize>>::Output[src]
impl<'_> Sub<&'_ isize> for isize[src]
type Output = <isize as Sub<isize>>::Output
pub fn sub(self, other: &isize) -> <isize as Sub<isize>>::Output[src]
impl Sub<u16> for u16[src]
impl Sub<u32> for u32[src]
impl<'_> Sub<&'_ i8> for i8[src]
impl<'_, '_> Sub<&'_ f32> for &'_ f32[src]
type Output = <f32 as Sub<f32>>::Output
pub fn sub(self, other: &f32) -> <f32 as Sub<f32>>::Output[src]
impl<'a> Sub<u64> for &'a u64[src]
type Output = <u64 as Sub<u64>>::Output
pub fn sub(self, other: u64) -> <u64 as Sub<u64>>::Output[src]
impl Sub<i64> for i64[src]
impl<'_> Sub<&'_ f64> for f64[src]
type Output = <f64 as Sub<f64>>::Output
pub fn sub(self, other: &f64) -> <f64 as Sub<f64>>::Output[src]
impl<'_, '_> Sub<&'_ Wrapping<isize>> for &'_ Wrapping<isize>[src]
type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
pub 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<f32> for f32[src]
impl Sub<i16> for i16[src]
impl<'_, '_> Sub<&'_ f64> for &'_ f64[src]
type Output = <f64 as Sub<f64>>::Output
pub fn sub(self, other: &f64) -> <f64 as Sub<f64>>::Output[src]
impl Sub<i8> for i8[src]
impl Sub<Wrapping<i8>> for Wrapping<i8>[src]
impl Sub<Wrapping<u32>> for Wrapping<u32>[src]
impl Sub<Wrapping<u128>> for Wrapping<u128>[src]
impl<'a> Sub<Wrapping<i32>> for &'a Wrapping<i32>[src]
type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
pub 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<u32> for &'a u32[src]
type Output = <u32 as Sub<u32>>::Output
pub fn sub(self, other: u32) -> <u32 as Sub<u32>>::Output[src]
impl<'_, '_> Sub<&'_ u16> for &'_ u16[src]
type Output = <u16 as Sub<u16>>::Output
pub fn sub(self, other: &u16) -> <u16 as Sub<u16>>::Output[src]
impl Sub<u128> for u128[src]
impl Sub<Wrapping<i64>> for Wrapping<i64>[src]
impl<'a> Sub<Wrapping<isize>> for &'a Wrapping<isize>[src]
type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
pub 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<u16> for &'a u16[src]
type Output = <u16 as Sub<u16>>::Output
pub fn sub(self, other: u16) -> <u16 as Sub<u16>>::Output[src]
impl Sub<Wrapping<isize>> for Wrapping<isize>[src]
impl<'_> Sub<&'_ u32> for u32[src]
type Output = <u32 as Sub<u32>>::Output
pub fn sub(self, other: &u32) -> <u32 as Sub<u32>>::Output[src]
impl<'_, '_> Sub<&'_ i8> for &'_ i8[src]
impl<'_, '_> Sub<&'_ Wrapping<i16>> for &'_ Wrapping<i16>[src]
type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
pub 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
pub 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<i128>> for &'a Wrapping<i128>[src]
type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
pub 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<u64>> for &'_ Wrapping<u64>[src]
type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
pub 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<i128>> for Wrapping<i128>[src]
impl<'_, '_> Sub<&'_ u128> for &'_ u128[src]
type Output = <u128 as Sub<u128>>::Output
pub fn sub(self, other: &u128) -> <u128 as Sub<u128>>::Output[src]
impl<'_> Sub<&'_ Wrapping<u64>> for Wrapping<u64>[src]
type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
pub 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
pub 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<&'_ i16> for &'_ i16[src]
type Output = <i16 as Sub<i16>>::Output
pub fn sub(self, other: &i16) -> <i16 as Sub<i16>>::Output[src]
impl<'_> Sub<&'_ u128> for u128[src]
type Output = <u128 as Sub<u128>>::Output
pub fn sub(self, other: &u128) -> <u128 as Sub<u128>>::Output[src]
impl Sub<Wrapping<i16>> for Wrapping<i16>[src]
impl<'_, '_> Sub<&'_ u32> for &'_ u32[src]
type Output = <u32 as Sub<u32>>::Output
pub fn sub(self, other: &u32) -> <u32 as Sub<u32>>::Output[src]
impl<'a> Sub<Wrapping<i64>> for &'a Wrapping<i64>[src]
type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
pub 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<&'_ i16> for i16[src]
type Output = <i16 as Sub<i16>>::Output
pub fn sub(self, other: &i16) -> <i16 as Sub<i16>>::Output[src]
impl<'_> Sub<&'_ Wrapping<i16>> for Wrapping<i16>[src]
type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output
pub 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<usize>> for Wrapping<usize>[src]
type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
pub 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]
impl<'a> Sub<i16> for &'a i16[src]
type Output = <i16 as Sub<i16>>::Output
pub fn sub(self, other: i16) -> <i16 as Sub<i16>>::Output[src]
impl<'a> Sub<u128> for &'a u128[src]
type Output = <u128 as Sub<u128>>::Output
pub fn sub(self, other: u128) -> <u128 as Sub<u128>>::Output[src]
impl<'_> Sub<&'_ f32> for f32[src]
type Output = <f32 as Sub<f32>>::Output
pub fn sub(self, other: &f32) -> <f32 as Sub<f32>>::Output[src]
impl<'_, '_> Sub<&'_ usize> for &'_ usize[src]
type Output = <usize as Sub<usize>>::Output
pub fn sub(self, other: &usize) -> <usize as Sub<usize>>::Output[src]
impl Sub<Wrapping<u16>> for Wrapping<u16>[src]
impl<'a> Sub<i64> for &'a i64[src]
type Output = <i64 as Sub<i64>>::Output
pub fn sub(self, other: i64) -> <i64 as Sub<i64>>::Output[src]
impl<'_, '_> Sub<&'_ Wrapping<u8>> for &'_ Wrapping<u8>[src]
type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
pub 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<isize>> for Wrapping<isize>[src]
type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output
pub 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<u8>> for &'a Wrapping<u8>[src]
type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
pub 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<'a> Sub<Wrapping<u32>> for &'a Wrapping<u32>[src]
type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
pub 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<i128> for i128[src]
impl<'a> Sub<usize> for &'a usize[src]
type Output = <usize as Sub<usize>>::Output
pub fn sub(self, other: usize) -> <usize as Sub<usize>>::Output[src]
impl<'_> Sub<&'_ i32> for i32[src]
type Output = <i32 as Sub<i32>>::Output
pub fn sub(self, other: &i32) -> <i32 as Sub<i32>>::Output[src]
impl<'a> Sub<f32> for &'a f32[src]
type Output = <f32 as Sub<f32>>::Output
pub fn sub(self, other: f32) -> <f32 as Sub<f32>>::Output[src]
impl<'_, '_> Sub<&'_ Wrapping<usize>> for &'_ Wrapping<usize>[src]
type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
pub 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<Wrapping<i8>> for &'a Wrapping<i8>[src]
type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
pub 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<i8> for &'a i8[src]
impl<'a> Sub<Wrapping<usize>> for &'a Wrapping<usize>[src]
type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output
pub 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<Wrapping<u64>> for &'a Wrapping<u64>[src]
type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output
pub 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<&'_ i64> for &'_ i64[src]
type Output = <i64 as Sub<i64>>::Output
pub fn sub(self, other: &i64) -> <i64 as Sub<i64>>::Output[src]
impl<'_> Sub<&'_ i64> for i64[src]
type Output = <i64 as Sub<i64>>::Output
pub fn sub(self, other: &i64) -> <i64 as Sub<i64>>::Output[src]
impl<'_> Sub<&'_ Wrapping<i32>> for Wrapping<i32>[src]
type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output
pub 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<isize> for &'a isize[src]
type Output = <isize as Sub<isize>>::Output
pub fn sub(self, other: isize) -> <isize as Sub<isize>>::Output[src]
impl Sub<Duration> for Duration[src]
impl Sub<i32> for i32[src]
impl Sub<u64> for u64[src]
impl<'_> Sub<&'_ Wrapping<u16>> for Wrapping<u16>[src]
type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output
pub 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<u32>> for &'_ Wrapping<u32>[src]
type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output
pub 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<f64> for &'a f64[src]
type Output = <f64 as Sub<f64>>::Output
pub fn sub(self, other: f64) -> <f64 as Sub<f64>>::Output[src]
impl<'_, '_> Sub<&'_ Wrapping<u128>> for &'_ Wrapping<u128>[src]
type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
pub 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<i128>> for &'_ Wrapping<i128>[src]
type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output
pub 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]
impl<'_, '_> Sub<&'_ i32> for &'_ i32[src]
type Output = <i32 as Sub<i32>>::Output
pub fn sub(self, other: &i32) -> <i32 as Sub<i32>>::Output[src]
impl<'_, '_> Sub<&'_ u8> for &'_ u8[src]
impl Sub<isize> for isize[src]
impl<'a> Sub<i128> for &'a i128[src]
type Output = <i128 as Sub<i128>>::Output
pub fn sub(self, other: i128) -> <i128 as Sub<i128>>::Output[src]
impl Sub<Wrapping<u64>> for Wrapping<u64>[src]
impl<'_> Sub<&'_ Wrapping<u128>> for Wrapping<u128>[src]
type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output
pub 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<i64>> for &'_ Wrapping<i64>[src]
type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output
pub 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]
type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output
pub 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<u8> for &'a u8[src]
impl<'_> Sub<&'_ Wrapping<u8>> for Wrapping<u8>[src]
type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output
pub 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<'_, '_, T> Sub<&'_ BTreeSet<T>> for &'_ BTreeSet<T> where
T: Clone + Ord, [src]
T: Clone + Ord,
type Output = BTreeSet<T>
pub 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<Tz> Sub<Date<Tz>> for Date<Tz> where
Tz: TimeZone, [src]
Tz: TimeZone,
impl<Tz> Sub<FixedOffset> for DateTime<Tz> where
Tz: TimeZone, [src]
Tz: TimeZone,
impl<Tz> Sub<DateTime<Tz>> for DateTime<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 Sub<FixedOffset> for NaiveDateTime[src]
type Output = NaiveDateTime
pub fn sub(self, rhs: FixedOffset) -> NaiveDateTime[src]
impl<Tz> Sub<Duration> for Date<Tz> where
Tz: TimeZone, [src]
Tz: TimeZone,
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 NaiveDateTimes 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 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
pub fn sub(self, rhs: Duration) -> NaiveDateTime[src]
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<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 NaiveTimes 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<Tz> Sub<Duration> for DateTime<Tz> where
Tz: TimeZone, [src]
Tz: TimeZone,
impl Sub<Duration> for Timespec[src]
impl Sub<Duration> for Duration[src]
impl Sub<Tm> for Tm[src]
impl Sub<SteadyTime> for SteadyTime[src]
impl Sub<Duration> for Tm[src]
impl Sub<Duration> for SteadyTime[src]
type Output = SteadyTime
pub fn sub(self, other: Duration) -> SteadyTime[src]
impl Sub<Timespec> for Timespec[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b u16[src]
impl<'a> Sub<usize> for &'a BigInt[src]
impl<'a> Sub<&'a u16> for BigInt[src]
impl Sub<BigInt> for usize[src]
impl<'a> Sub<u16> for &'a BigUint[src]
impl<'a, 'b> Sub<&'b u64> for &'a BigUint[src]
impl<'a> Sub<i8> for &'a BigInt[src]
impl<'a> Sub<u16> for &'a BigInt[src]
impl<'a> Sub<&'a BigUint> for u128[src]
impl<'a> Sub<BigInt> for &'a i64[src]
impl<'a> Sub<BigUint> for &'a u32[src]
impl<'a> Sub<&'a u64> for BigUint[src]
impl<'a> Sub<&'a u8> for BigInt[src]
impl<'a> Sub<&'a BigInt> for i16[src]
impl<'a> Sub<BigInt> for &'a i32[src]
impl<'a, 'b> Sub<&'b u32> for &'a BigInt[src]
impl Sub<u64> for BigInt[src]
impl<'a> Sub<&'a BigInt> for u16[src]
impl Sub<BigInt> for i128[src]
impl<'a> Sub<BigInt> for &'a i16[src]
impl Sub<u16> for BigInt[src]
impl<'a> Sub<&'a i128> for BigInt[src]
impl<'a> Sub<u64> for &'a BigUint[src]
impl<'a> Sub<BigInt> for &'a u64[src]
impl<'a> Sub<u128> for &'a BigInt[src]
impl<'a> Sub<BigInt> for &'a u128[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b usize[src]
impl<'a> Sub<i128> for &'a BigInt[src]
impl Sub<i32> for BigInt[src]
impl Sub<BigUint> for BigUint[src]
impl<'a> Sub<&'a u8> for BigUint[src]
impl<'a> Sub<&'a usize> for BigInt[src]
impl<'a> Sub<&'a BigInt> for u64[src]
impl<'a> Sub<&'a i8> for BigInt[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b i16[src]
impl<'a> Sub<&'a BigInt> for usize[src]
impl<'a> Sub<&'a BigUint> for u32[src]
impl Sub<usize> for BigUint[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b u32[src]
impl<'a> Sub<&'a BigUint> for u64[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b i8[src]
impl Sub<u32> for BigUint[src]
impl<'a> Sub<&'a isize> for BigInt[src]
impl Sub<isize> for BigInt[src]
impl<'a> Sub<&'a BigInt> for BigInt[src]
impl<'a> Sub<u8> for &'a BigUint[src]
impl<'a> Sub<isize> for &'a BigInt[src]
impl<'a, 'b> Sub<&'b BigInt> for &'a BigInt[src]
impl<'a, 'b> Sub<&'b usize> for &'a BigInt[src]
impl<'a> Sub<BigInt> for &'a i8[src]
impl<'a, 'b> Sub<&'b BigUint> for &'a BigUint[src]
impl Sub<BigInt> for u64[src]
impl<'a> Sub<&'a i16> for BigInt[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b u128[src]
impl<'a> Sub<BigInt> for &'a u8[src]
impl Sub<BigInt> for u8[src]
impl<'a> Sub<BigUint> for &'a u8[src]
impl<'a> Sub<i16> for &'a BigInt[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b i32[src]
impl<'a> Sub<BigInt> for &'a isize[src]
impl Sub<usize> for BigInt[src]
impl<'a, 'b> Sub<&'a BigUint> for &'b usize[src]
impl<'a> Sub<BigUint> for &'a u16[src]
impl<'a, 'b> Sub<&'b u64> for &'a BigInt[src]
impl Sub<u8> for BigInt[src]
impl<'a> Sub<u8> for &'a BigInt[src]
impl Sub<BigUint> for u32[src]
impl<'a> Sub<&'a BigInt> for i64[src]
impl<'a, 'b> Sub<&'b i8> for &'a BigInt[src]
impl Sub<BigUint> for u16[src]
impl Sub<BigInt> for i16[src]
impl Sub<BigInt> for i64[src]
impl<'a, 'b> Sub<&'b u8> for &'a BigUint[src]
impl<'a> Sub<BigUint> for &'a u64[src]
impl<'a> Sub<BigInt> for &'a u32[src]
impl<'a> Sub<&'a usize> for BigUint[src]
impl Sub<BigInt> for u16[src]
impl<'a> Sub<BigUint> for &'a BigUint[src]
impl<'a, 'b> Sub<&'b u16> for &'a BigUint[src]
impl<'a> Sub<BigUint> for &'a u128[src]
impl<'a> Sub<&'a BigInt> for u8[src]
impl<'a> Sub<&'a BigUint> for u8[src]
impl<'a> Sub<BigInt> for &'a usize[src]
impl Sub<BigInt> for BigInt[src]
impl<'a> Sub<&'a BigInt> for u128[src]
impl<'a> Sub<&'a BigInt> for i32[src]
impl<'a, 'b> Sub<&'b isize> for &'a BigInt[src]
impl<'a, 'b> Sub<&'b u128> for &'a BigInt[src]
impl Sub<BigInt> for i8[src]
impl<'a, 'b> Sub<&'b i64> for &'a BigInt[src]
impl Sub<BigInt> for u128[src]
impl Sub<u64> for BigUint[src]
impl<'a> Sub<BigInt> for &'a BigInt[src]
impl<'a> Sub<u128> for &'a BigUint[src]
impl<'a, 'b> Sub<&'a BigUint> for &'b u16[src]
impl<'a> Sub<&'a BigInt> for i128[src]
impl<'a> Sub<BigUint> for &'a usize[src]
impl<'a, 'b> Sub<&'a BigUint> for &'b u64[src]
impl<'a> Sub<usize> for &'a BigUint[src]
impl Sub<BigUint> for u8[src]
impl<'a, 'b> Sub<&'b usize> for &'a BigUint[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b u8[src]
impl<'a, 'b> Sub<&'a BigUint> for &'b u128[src]
impl Sub<u128> for BigInt[src]
impl<'a> Sub<i32> for &'a BigInt[src]
impl Sub<i64> for BigInt[src]
impl Sub<BigUint> for u64[src]
impl Sub<u128> for BigUint[src]
impl<'a> Sub<u64> for &'a BigInt[src]
impl Sub<i8> for BigInt[src]
impl<'a> Sub<&'a BigInt> for isize[src]
impl<'a> Sub<&'a i64> for BigInt[src]
impl<'a> Sub<&'a BigUint> for usize[src]
impl<'a, 'b> Sub<&'a BigUint> for &'b u8[src]
impl Sub<u8> for BigUint[src]
impl<'a> Sub<&'a BigInt> for u32[src]
impl<'a> Sub<BigInt> for &'a i128[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b i64[src]
impl<'a> Sub<&'a u32> for BigInt[src]
impl<'a, 'b> Sub<&'b u32> for &'a BigUint[src]
impl Sub<BigUint> for u128[src]
impl<'a, 'b> Sub<&'b i16> for &'a BigInt[src]
impl<'a, 'b> Sub<&'b u128> for &'a BigUint[src]
impl<'a> Sub<&'a BigInt> for i8[src]
impl<'a> Sub<&'a u128> for BigUint[src]
impl<'a, 'b> Sub<&'b i128> for &'a BigInt[src]
impl<'a, 'b> Sub<&'b i32> for &'a BigInt[src]
impl<'a> Sub<&'a i32> for BigInt[src]
impl<'a, 'b> Sub<&'a BigUint> for &'b u32[src]
impl Sub<u16> for BigUint[src]
impl<'a, 'b> Sub<&'b u8> for &'a BigInt[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b isize[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b u64[src]
impl<'a> Sub<u32> for &'a BigInt[src]
impl Sub<i16> for BigInt[src]
impl<'a> Sub<&'a BigUint> for u16[src]
impl<'a> Sub<&'a u128> for BigInt[src]
impl<'a, 'b> Sub<&'a BigInt> for &'b i128[src]
impl<'a> Sub<BigInt> for &'a u16[src]
impl<'a> Sub<i64> for &'a BigInt[src]
impl<'a> Sub<&'a BigUint> for BigUint[src]
impl Sub<i128> for BigInt[src]
impl<'a> Sub<&'a u64> for BigInt[src]
impl<'a> Sub<&'a u16> for BigUint[src]
impl<'a, 'b> Sub<&'b u16> for &'a BigInt[src]
impl Sub<BigInt> for u32[src]
impl Sub<BigUint> for usize[src]
impl<'a> Sub<u32> for &'a BigUint[src]
impl Sub<u32> for BigInt[src]
impl<'a> Sub<&'a u32> for BigUint[src]
impl Sub<BigInt> for i32[src]
impl Sub<BigInt> for isize[src]
impl<'a> Sub<Complex<u32>> for &'a u32[src]
impl<'a, 'b, T> Sub<&'b Complex<T>> for &'a Complex<T> where
T: Clone + Num, [src]
T: Clone + Num,
type Output = Complex<T>
pub fn sub(
self,
other: &Complex<T>
) -> <&'a Complex<T> as Sub<&'b Complex<T>>>::Output[src]
self,
other: &Complex<T>
) -> <&'a Complex<T> as Sub<&'b Complex<T>>>::Output
impl<T> Sub<Complex<T>> for Complex<T> where
T: Clone + Num, [src]
T: Clone + Num,
type Output = Complex<T>
pub fn sub(self, other: Complex<T>) -> <Complex<T> as Sub<Complex<T>>>::Output[src]
impl<'a, 'b> Sub<&'a Complex<u64>> for &'b u64[src]
impl<'a> Sub<Complex<i16>> for &'a i16[src]
impl<'a> Sub<&'a Complex<f64>> for f64[src]
impl<'a> Sub<Complex<f64>> for &'a f64[src]
impl<'a, 'b> Sub<&'a Complex<i64>> for &'b i64[src]
impl<'a> Sub<&'a Complex<f32>> for f32[src]
impl Sub<Complex<i128>> for i128[src]
type Output = Complex<i128>
pub fn sub(self, other: Complex<i128>) -> <i128 as Sub<Complex<i128>>>::Output[src]
impl<'a, T> Sub<&'a Complex<T>> for Complex<T> where
T: Clone + Num, [src]
T: Clone + Num,
type Output = Complex<T>
pub fn sub(
self,
other: &Complex<T>
) -> <Complex<T> as Sub<&'a Complex<T>>>::Output[src]
self,
other: &Complex<T>
) -> <Complex<T> as Sub<&'a Complex<T>>>::Output
impl<'a, 'b> Sub<&'a Complex<isize>> for &'b isize[src]
impl Sub<Complex<isize>> for isize[src]
type Output = Complex<isize>
pub fn sub(
self,
other: Complex<isize>
) -> <isize as Sub<Complex<isize>>>::Output[src]
self,
other: Complex<isize>
) -> <isize as Sub<Complex<isize>>>::Output
impl<'a> Sub<Complex<i32>> for &'a i32[src]
impl<'a, 'b> Sub<&'a Complex<i128>> for &'b i128[src]
impl<'a> Sub<Complex<i128>> for &'a i128[src]
impl<'a> Sub<&'a Complex<isize>> for isize[src]
impl Sub<Complex<usize>> for usize[src]
type Output = Complex<usize>
pub fn sub(
self,
other: Complex<usize>
) -> <usize as Sub<Complex<usize>>>::Output[src]
self,
other: Complex<usize>
) -> <usize as Sub<Complex<usize>>>::Output
impl<'a> Sub<&'a Complex<i8>> for i8[src]
impl<'a> Sub<Complex<i8>> for &'a i8[src]
impl<'a, 'b> Sub<&'a Complex<i8>> for &'b i8[src]
impl Sub<Complex<u128>> for u128[src]
type Output = Complex<u128>
pub fn sub(self, other: Complex<u128>) -> <u128 as Sub<Complex<u128>>>::Output[src]
impl<'a, T> Sub<&'a T> for Complex<T> where
T: Clone + Num, [src]
T: Clone + Num,
impl<'a> Sub<Complex<usize>> for &'a usize[src]
impl Sub<Complex<i32>> for i32[src]
type Output = Complex<i32>
pub fn sub(self, other: Complex<i32>) -> <i32 as Sub<Complex<i32>>>::Output[src]
impl<'a> Sub<&'a Complex<u32>> for u32[src]
impl<'a> Sub<Complex<u64>> for &'a u64[src]
impl<'a, 'b> Sub<&'a Complex<f32>> for &'b f32[src]
impl<'a, 'b> Sub<&'a Complex<i32>> for &'b i32[src]
impl<'a, 'b> Sub<&'a Complex<u16>> for &'b u16[src]
impl<'a, T> Sub<Complex<T>> for &'a Complex<T> where
T: Clone + Num, [src]
T: Clone + Num,
type Output = Complex<T>
pub fn sub(
self,
other: Complex<T>
) -> <&'a Complex<T> as Sub<Complex<T>>>::Output[src]
self,
other: Complex<T>
) -> <&'a Complex<T> as Sub<Complex<T>>>::Output
impl<'a> Sub<&'a Complex<u16>> for u16[src]
impl<'a, 'b> Sub<&'a Complex<u32>> for &'b u32[src]
impl<'a> Sub<&'a Complex<i128>> for i128[src]
impl Sub<Complex<u16>> for u16[src]
type Output = Complex<u16>
pub fn sub(self, other: Complex<u16>) -> <u16 as Sub<Complex<u16>>>::Output[src]
impl<'a, 'b> Sub<&'a Complex<u128>> for &'b u128[src]
impl<'a> Sub<Complex<i64>> for &'a i64[src]
impl Sub<Complex<i16>> for i16[src]
type Output = Complex<i16>
pub fn sub(self, other: Complex<i16>) -> <i16 as Sub<Complex<i16>>>::Output[src]
impl<'a, 'b> Sub<&'a Complex<i16>> for &'b i16[src]
impl<'a, 'b, T> Sub<&'a T> for &'b Complex<T> where
T: Clone + Num, [src]
T: Clone + Num,
impl<'a> Sub<&'a Complex<u64>> for u64[src]
impl Sub<Complex<i8>> for i8[src]
type Output = Complex<i8>
pub fn sub(self, other: Complex<i8>) -> <i8 as Sub<Complex<i8>>>::Output[src]
impl<'a> Sub<Complex<isize>> for &'a isize[src]
impl<'a> Sub<Complex<u16>> for &'a u16[src]
impl Sub<Complex<u8>> for u8[src]
type Output = Complex<u8>
pub fn sub(self, other: Complex<u8>) -> <u8 as Sub<Complex<u8>>>::Output[src]
impl Sub<Complex<u64>> for u64[src]
type Output = Complex<u64>
pub fn sub(self, other: Complex<u64>) -> <u64 as Sub<Complex<u64>>>::Output[src]
impl<'a> Sub<&'a Complex<i16>> for i16[src]
impl<'a> Sub<&'a Complex<u8>> for u8[src]
impl<'a> Sub<&'a Complex<i64>> for i64[src]
impl<'a, T> Sub<T> for &'a Complex<T> where
T: Clone + Num, [src]
T: Clone + Num,
impl<'a> Sub<&'a Complex<i32>> for i32[src]
impl<'a> Sub<Complex<u128>> for &'a u128[src]
impl Sub<Complex<i64>> for i64[src]
type Output = Complex<i64>
pub fn sub(self, other: Complex<i64>) -> <i64 as Sub<Complex<i64>>>::Output[src]
impl Sub<Complex<f32>> for f32[src]
type Output = Complex<f32>
pub fn sub(self, other: Complex<f32>) -> <f32 as Sub<Complex<f32>>>::Output[src]
impl<T> Sub<T> for Complex<T> where
T: Clone + Num, [src]
T: Clone + Num,
impl<'a, 'b> Sub<&'a Complex<usize>> for &'b usize[src]
impl<'a, 'b> Sub<&'a Complex<f64>> for &'b f64[src]
impl<'a> Sub<Complex<u8>> for &'a u8[src]
impl Sub<Complex<f64>> for f64[src]
type Output = Complex<f64>
pub fn sub(self, other: Complex<f64>) -> <f64 as Sub<Complex<f64>>>::Output[src]
impl<'a> Sub<&'a Complex<u128>> for u128[src]
impl Sub<Complex<u32>> for u32[src]
type Output = Complex<u32>
pub fn sub(self, other: Complex<u32>) -> <u32 as Sub<Complex<u32>>>::Output[src]
impl<'a> Sub<&'a Complex<usize>> for usize[src]
impl<'a, 'b> Sub<&'a Complex<u8>> for &'b u8[src]
impl<'a> Sub<Complex<f32>> for &'a f32[src]
impl<'a, T> Sub<&'a T> for Ratio<T> where
T: Clone + Integer, [src]
T: Clone + Integer,
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<T> Sub<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, '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<'a, '_, K, V, S, Q> Sub<&'_ Q> for &'a DashMap<K, V, S> where
V: 'a,
S: Clone + BuildHasher,
Q: Hash + Eq + ?Sized,
K: 'a + Eq + Hash + Borrow<Q>,
V: 'a,
S: Clone + BuildHasher,
Q: Hash + Eq + ?Sized,
K: 'a + Eq + Hash + Borrow<Q>,
type Output = Option<(K, V)>
pub fn sub(self, key: &Q) -> <&'a DashMap<K, V, S> as Sub<&'_ Q>>::Output
impl<U, B> Sub<B1> for UInt<UInt<U, B>, B1> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
UInt<U, B1> - B1 = UInt<U, B0>
impl<U> Sub<NInt<U>> for Z0 where
U: NonZero + Unsigned,
U: NonZero + Unsigned,
Z0 - N = P
impl Sub<B1> for UInt<UTerm, B1>
UInt<UTerm, B1> - B1 = UTerm
impl<U> Sub<PInt<U>> for Z0 where
U: NonZero + Unsigned,
U: NonZero + Unsigned,
Z0 - P = N
impl<U> Sub<Z0> for PInt<U> where
U: NonZero + Unsigned,
U: NonZero + Unsigned,
PInt - Z0 = PInt
impl<Ul, Ur> Sub<PInt<Ur>> for NInt<Ul> where
Ul: NonZero + Unsigned + Add<Ur>,
Ur: NonZero + Unsigned,
<Ul as Add<Ur>>::Output: Unsigned,
<Ul as Add<Ur>>::Output: NonZero,
Ul: NonZero + Unsigned + Add<Ur>,
Ur: NonZero + Unsigned,
<Ul as Add<Ur>>::Output: Unsigned,
<Ul as Add<Ur>>::Output: NonZero,
N(Ul) - P(Ur) = N(Ul + Ur)
type Output = NInt<<Ul as Add<Ur>>::Output>
pub fn sub(self, PInt<Ur>) -> <NInt<Ul> as Sub<PInt<Ur>>>::Output
impl Sub<UTerm> for UTerm
UTerm - UTerm = UTerm
impl<U> Sub<Z0> for NInt<U> where
U: NonZero + Unsigned,
U: NonZero + Unsigned,
NInt - Z0 = NInt
impl Sub<B0> for UTerm
UTerm - B0 = Term
impl<U> Sub<B1> for UInt<U, B0> where
U: Unsigned + Sub<B1>,
<U as Sub<B1>>::Output: Unsigned,
U: Unsigned + Sub<B1>,
<U as Sub<B1>>::Output: Unsigned,
UInt<U, B0> - B1 = UInt<U - B1, B1>
type Output = UInt<<U as Sub<B1>>::Output, B1>
pub fn sub(self, B1) -> <UInt<U, B0> as Sub<B1>>::Output
impl<Vl, Al, Vr, Ar> Sub<TArr<Vr, Ar>> for TArr<Vl, Al> where
Vl: Sub<Vr>,
Al: Sub<Ar>,
Vl: Sub<Vr>,
Al: Sub<Ar>,
type Output = TArr<<Vl as Sub<Vr>>::Output, <Al as Sub<Ar>>::Output>
pub fn sub(
self,
rhs: TArr<Vr, Ar>
) -> <TArr<Vl, Al> as Sub<TArr<Vr, Ar>>>::Output
self,
rhs: TArr<Vr, Ar>
) -> <TArr<Vl, Al> as Sub<TArr<Vr, Ar>>>::Output
impl Sub<ATerm> for ATerm
impl<Ul, Ur> Sub<NInt<Ur>> for NInt<Ul> where
Ul: NonZero + Unsigned,
Ur: NonZero + Unsigned + Cmp<Ul> + PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>,
Ul: NonZero + Unsigned,
Ur: NonZero + Unsigned + Cmp<Ul> + PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>,
N(Ul) - N(Ur): We resolve this with our PrivateAdd
type Output = <Ur as PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>>::Output
pub fn sub(self, rhs: NInt<Ur>) -> <NInt<Ul> as Sub<NInt<Ur>>>::Output
impl Sub<Z0> for Z0
Z0 - Z0 = Z0
impl<U, B> Sub<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
UInt - B0 = UInt
impl<Ul, Ur> Sub<PInt<Ur>> for PInt<Ul> where
Ul: NonZero + Unsigned + Cmp<Ur> + PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>,
Ur: NonZero + Unsigned,
Ul: NonZero + Unsigned + Cmp<Ur> + PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>,
Ur: NonZero + Unsigned,
P(Ul) - P(Ur): We resolve this with our PrivateAdd
type Output = <Ul as PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>>::Output
pub fn sub(self, rhs: PInt<Ur>) -> <PInt<Ul> as Sub<PInt<Ur>>>::Output
impl<Ul, Ur> Sub<NInt<Ur>> for PInt<Ul> where
Ul: NonZero + Unsigned + Add<Ur>,
Ur: NonZero + Unsigned,
<Ul as Add<Ur>>::Output: Unsigned,
<Ul as Add<Ur>>::Output: NonZero,
Ul: NonZero + Unsigned + Add<Ur>,
Ur: NonZero + Unsigned,
<Ul as Add<Ur>>::Output: Unsigned,
<Ul as Add<Ur>>::Output: NonZero,
P(Ul) - N(Ur) = P(Ul + Ur)
type Output = PInt<<Ul as Add<Ur>>::Output>
pub fn sub(self, NInt<Ur>) -> <PInt<Ul> as Sub<NInt<Ur>>>::Output
impl<Ul, Bl, Ur> Sub<Ur> for UInt<Ul, Bl> where
Ul: Unsigned,
Ur: Unsigned,
Bl: Bit,
UInt<Ul, Bl>: PrivateSub<Ur>,
<UInt<Ul, Bl> as PrivateSub<Ur>>::Output: Trim,
Ul: Unsigned,
Ur: Unsigned,
Bl: Bit,
UInt<Ul, Bl>: PrivateSub<Ur>,
<UInt<Ul, Bl> as PrivateSub<Ur>>::Output: Trim,
Subtracting unsigned integers. We just do our PrivateSub and then Trim the output.
type Output = <<UInt<Ul, Bl> as PrivateSub<Ur>>::Output as Trim>::Output
pub fn sub(self, rhs: Ur) -> <UInt<Ul, Bl> as Sub<Ur>>::Output
impl Sub<Instant> for Instant[src]
impl Sub<Duration> for Instant[src]
impl Sub<Ready> for Ready[src]
impl Sub<CMSOptions> for CMSOptions[src]
type Output = CMSOptions
pub fn sub(self, other: CMSOptions) -> CMSOptions[src]
Returns the set difference of the two sets of flags.
impl Sub<Pkcs7Flags> for Pkcs7Flags[src]
type Output = Pkcs7Flags
pub fn sub(self, other: Pkcs7Flags) -> Pkcs7Flags[src]
Returns the set difference of the two sets of flags.
impl Sub<OcspFlag> for OcspFlag[src]
type Output = OcspFlag
pub fn sub(self, other: OcspFlag) -> OcspFlag[src]
Returns the set difference of the two sets of flags.
impl<'a, 'b> Sub<&'b BigNumRef> for &'a BigNumRef[src]
impl<'a, 'b> Sub<&'b BigNum> for &'a BigNum[src]
impl Sub<X509VerifyFlags> for X509VerifyFlags[src]
type Output = X509VerifyFlags
pub fn sub(self, other: X509VerifyFlags) -> X509VerifyFlags[src]
Returns the set difference of the two sets of flags.
impl Sub<SslOptions> for SslOptions[src]
type Output = SslOptions
pub fn sub(self, other: SslOptions) -> SslOptions[src]
Returns the set difference of the two sets of flags.
impl Sub<SslSessionCacheMode> for SslSessionCacheMode[src]
type Output = SslSessionCacheMode
pub fn sub(self, other: SslSessionCacheMode) -> SslSessionCacheMode[src]
Returns the set difference of the two sets of flags.
impl Sub<SslVerifyMode> for SslVerifyMode[src]
type Output = SslVerifyMode
pub fn sub(self, other: SslVerifyMode) -> SslVerifyMode[src]
Returns the set difference of the two sets of flags.
impl Sub<SslMode> for SslMode[src]
type Output = SslMode
pub fn sub(self, other: SslMode) -> SslMode[src]
Returns the set difference of the two sets of flags.
impl Sub<ExtensionContext> for ExtensionContext[src]
type Output = ExtensionContext
pub fn sub(self, other: ExtensionContext) -> ExtensionContext[src]
Returns the set difference of the two sets of flags.
impl Sub<ShutdownState> for ShutdownState[src]
type Output = ShutdownState
pub fn sub(self, other: ShutdownState) -> ShutdownState[src]
Returns the set difference of the two sets of flags.
impl<'a, 'b> Sub<&'b BigNum> for &'a BigNumRef[src]
impl Sub<X509CheckFlags> for X509CheckFlags[src]
type Output = X509CheckFlags
pub fn sub(self, other: X509CheckFlags) -> X509CheckFlags[src]
Returns the set difference of the two sets of flags.
impl<'a, 'b> Sub<&'b BigNumRef> for &'a BigNum[src]
impl Sub<Duration> for Instant[src]
impl Sub<Instant> for Instant[src]
impl<T> Sub<T> for Ready where
T: Into<Ready>, [src]
T: Into<Ready>,
impl Sub<UnixReady> for UnixReady[src]
impl Sub<PollOpt> for PollOpt[src]
impl<'_, '_, T, S1, S2> Sub<&'_ IndexSet<T, S2>> for &'_ IndexSet<T, S1> where
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher, [src]
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
type Output = IndexSet<T, S1>
pub fn sub(
self,
other: &IndexSet<T, S2>
) -> <&'_ IndexSet<T, S1> as Sub<&'_ IndexSet<T, S2>>>::Output[src]
self,
other: &IndexSet<T, S2>
) -> <&'_ IndexSet<T, S1> as Sub<&'_ IndexSet<T, S2>>>::Output
Returns the set difference, cloned into a new set.
Values are collected in the same order that they appear in self.
impl<'_, '_, T, S> Sub<&'_ HashSet<T, S>> for &'_ HashSet<T, S> where
T: Eq + Hash + Clone,
S: BuildHasher + Default,
T: Eq + Hash + Clone,
S: BuildHasher + Default,
type Output = HashSet<T, S>
pub 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());