Trait Difference 

pub trait Difference<RHS = Self> {
    type Output;

    // Required method
    fn difference(&self, rhs: &RHS) -> Self::Output;
}

Required Associated Types

type Output

Required Methods

fn difference(&self, rhs: &RHS) -> Self::Output

Implementations on Foreign Types

impl Difference<Optional<bool>> for bool

type Output = Optional<bool>

fn difference( &self, other: &Optional<bool>, ) -> <bool as Difference<Optional<bool>>>::Output

impl Difference<Optional<char>> for char

type Output = Optional<char>

fn difference( &self, other: &Optional<char>, ) -> <char as Difference<Optional<char>>>::Output

impl Difference<Optional<f32>> for f32

type Output = Optional<f32>

fn difference( &self, other: &Optional<f32>, ) -> <f32 as Difference<Optional<f32>>>::Output

impl Difference<Optional<f64>> for f64

type Output = Optional<f64>

fn difference( &self, other: &Optional<f64>, ) -> <f64 as Difference<Optional<f64>>>::Output

impl Difference<Optional<i8>> for i8

type Output = Optional<i8>

fn difference( &self, other: &Optional<i8>, ) -> <i8 as Difference<Optional<i8>>>::Output

impl Difference<Optional<i16>> for i16

type Output = Optional<i16>

fn difference( &self, other: &Optional<i16>, ) -> <i16 as Difference<Optional<i16>>>::Output

impl Difference<Optional<i32>> for i32

type Output = Optional<i32>

fn difference( &self, other: &Optional<i32>, ) -> <i32 as Difference<Optional<i32>>>::Output

impl Difference<Optional<i64>> for i64

type Output = Optional<i64>

fn difference( &self, other: &Optional<i64>, ) -> <i64 as Difference<Optional<i64>>>::Output

impl Difference<Optional<isize>> for isize

type Output = Optional<isize>

fn difference( &self, other: &Optional<isize>, ) -> <isize as Difference<Optional<isize>>>::Output

impl Difference<Optional<u8>> for u8

type Output = Optional<u8>

fn difference( &self, other: &Optional<u8>, ) -> <u8 as Difference<Optional<u8>>>::Output

impl Difference<Optional<u16>> for u16

type Output = Optional<u16>

fn difference( &self, other: &Optional<u16>, ) -> <u16 as Difference<Optional<u16>>>::Output

impl Difference<Optional<u32>> for u32

type Output = Optional<u32>

fn difference( &self, other: &Optional<u32>, ) -> <u32 as Difference<Optional<u32>>>::Output

impl Difference<Optional<u64>> for u64

type Output = Optional<u64>

fn difference( &self, other: &Optional<u64>, ) -> <u64 as Difference<Optional<u64>>>::Output

impl Difference<Optional<usize>> for usize

type Output = Optional<usize>

fn difference( &self, other: &Optional<usize>, ) -> <usize as Difference<Optional<usize>>>::Output

Implementors

impl Difference for BitSet

type Output = BitSet

impl Difference<Interval<i8>> for Optional<i8>

type Output = Optional<i8>

impl Difference<Interval<i16>> for Optional<i16>

type Output = Optional<i16>

impl Difference<Interval<i32>> for Optional<i32>

type Output = Optional<i32>

impl Difference<Interval<i64>> for Optional<i64>

type Output = Optional<i64>

impl Difference<Interval<isize>> for Optional<isize>

type Output = Optional<isize>

impl Difference<Interval<u8>> for Optional<u8>

type Output = Optional<u8>

impl Difference<Interval<u16>> for Optional<u16>

type Output = Optional<u16>

impl Difference<Interval<u32>> for Optional<u32>

type Output = Optional<u32>

impl Difference<Interval<u64>> for Optional<u64>

type Output = Optional<u64>

impl Difference<Interval<usize>> for Optional<usize>

type Output = Optional<usize>

impl<Bound> Difference for Interval<Bound>

where Bound: Width + Num,

type Output = Interval<Bound>

impl<Bound> Difference<Optional<Bound>> for Interval<Bound>

where Bound: Ord + Num + Clone,

type Output = Interval<Bound>

impl<Bound> Difference<Bound> for Interval<Bound>

where Bound: Num + Clone,

type Output = Interval<Bound>

impl<Bound> Difference<Bound> for IntervalSet<Bound>

where Bound: Width + Num + Clone,

type Output = IntervalSet<Bound>

impl<Bound: Width + Num> Difference for IntervalSet<Bound>

type Output = IntervalSet<Bound>

impl<T> Difference for BTreeSet<T>

where T: Ord + Clone,

type Output = BTreeSet<T>

impl<T> Difference for Optional<T>

where T: Clone + PartialEq,

type Output = Optional<T>

impl<T> Difference<T> for Optional<T>

where T: Clone + PartialEq,

type Output = Optional<T>

impl<T, S> Difference for HashSet<T, S>

where T: Eq + Hash + Clone, S: BuildHasher + Default,

type Output = HashSet<T, S>