Trait bitsetium::BitDifference[−][src]

pub trait BitDifference<Rhs = Self> {
    type Output;
    fn difference(self, rhs: Rhs) -> Self::Output;
}

Expand description

Difference between two subsets.

Associated Types

[src]

type Output

Required methods

[src]

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

Returns bit-set has bits set for each index that has bit set in exactly one of two arguments.

Implementations on Foreign Types

[src]

impl<T, U> BitDifference for &T

type Output = Difference<Self, U>

[src]

fn difference(self, rhs: U) -> Difference<Self, U>

[src]

impl<T, U> BitDifference for &mut T

type Output = Difference<Self, U>

[src]

fn difference(self, rhs: U) -> Difference<Self, U>

[src]

impl<T, U> BitDifference for Box<T>

type Output = Difference<Self, U>

[src]

fn difference(self, rhs: U) -> Difference<Self, U>

[src]

impl<T, U> BitDifference for Option<T> where
T: BitDifference,

type Output = Option<T::Output>

[src]

fn difference(self, rhs: U) -> Option<T::Output>

[src]

impl BitDifference<u8> for u8

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl BitDifference<Complement<u8>> for u8

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl<const N: usize> BitDifference<[u8 ; N]> for [u8 ; N]

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl<const N: usize> BitDifference<Complement<[u8 ; N]>> for [u8 ; N]

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl BitDifference<u16> for u16

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl BitDifference<Complement<u16>> for u16

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl<const N: usize> BitDifference<[u16 ; N]> for [u16 ; N]

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl<const N: usize> BitDifference<Complement<[u16 ; N]>> for [u16 ; N]

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl BitDifference<u32> for u32

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl BitDifference<Complement<u32>> for u32

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl<const N: usize> BitDifference<[u32 ; N]> for [u32 ; N]

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl<const N: usize> BitDifference<Complement<[u32 ; N]>> for [u32 ; N]

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl BitDifference<u64> for u64

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl BitDifference<Complement<u64>> for u64

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl<const N: usize> BitDifference<[u64 ; N]> for [u64 ; N]

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl<const N: usize> BitDifference<Complement<[u64 ; N]>> for [u64 ; N]

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl BitDifference<u128> for u128

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl BitDifference<Complement<u128>> for u128

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl<const N: usize> BitDifference<[u128 ; N]> for [u128 ; N]

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl<const N: usize> BitDifference<Complement<[u128 ; N]>> for [u128 ; N]

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

[src]

impl BitDifference<bool> for bool

type Output = Self

[src]

fn difference(self, rhs: Self) -> Self

[src]

impl BitDifference<Complement<bool>> for bool

type Output = Self

[src]

fn difference(self, rhs: Complement<Self>) -> Self

Implementors

[src]

impl<T, B, U, const N: usize> BitDifference for Layered<T, B, N>

type Output = Difference<Self, U>

[src]

impl<T, U> BitDifference for Complement<T> where
T: BitUnion,

type Output = Complement<<T as BitUnion>::Output>

[src]

impl<T, U, Y> BitDifference<Y> for Difference<T, U> where
T: BitDifference<Y>,

type Output = Difference<T::Output, U>

[src]

impl<T, U, Y> BitDifference<Y> for Intersection<T, U> where
T: BitDifference<Y>,

type Output = Intersection<T::Output, U>

[src]

Trait bitsetium::BitDifference[−][src]

Associated Types

type Output

Required methods

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

Implementations on Foreign Types

impl<T, U> BitDifference<U> for &T

type Output = Difference<Self, U>

fn difference(self, rhs: U) -> Difference<Self, U>

impl<T, U> BitDifference<U> for &mut T

type Output = Difference<Self, U>

fn difference(self, rhs: U) -> Difference<Self, U>

impl<T, U> BitDifference<U> for Box<T>

type Output = Difference<Self, U>

fn difference(self, rhs: U) -> Difference<Self, U>

impl<T, U> BitDifference<U> for Option<T> where T: BitDifference<U>,

type Output = Option<T::Output>

fn difference(self, rhs: U) -> Option<T::Output>

impl BitDifference<u8> for u8

type Output = Self

fn difference(self, rhs: Self) -> Self

impl BitDifference<Complement<u8>> for u8

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl<const N: usize> BitDifference<[u8; N]> for [u8; N]

type Output = Self

fn difference(self, rhs: Self) -> Self

impl<const N: usize> BitDifference<Complement<[u8; N]>> for [u8; N]

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl BitDifference<u16> for u16

type Output = Self

fn difference(self, rhs: Self) -> Self

impl BitDifference<Complement<u16>> for u16

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl<const N: usize> BitDifference<[u16; N]> for [u16; N]

type Output = Self

fn difference(self, rhs: Self) -> Self

impl<const N: usize> BitDifference<Complement<[u16; N]>> for [u16; N]

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl BitDifference<u32> for u32

type Output = Self

fn difference(self, rhs: Self) -> Self

impl BitDifference<Complement<u32>> for u32

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl<const N: usize> BitDifference<[u32; N]> for [u32; N]

type Output = Self

fn difference(self, rhs: Self) -> Self

impl<const N: usize> BitDifference<Complement<[u32; N]>> for [u32; N]

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl BitDifference<u64> for u64

type Output = Self

fn difference(self, rhs: Self) -> Self

impl BitDifference<Complement<u64>> for u64

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl<const N: usize> BitDifference<[u64; N]> for [u64; N]

type Output = Self

fn difference(self, rhs: Self) -> Self

impl<const N: usize> BitDifference<Complement<[u64; N]>> for [u64; N]

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl BitDifference<u128> for u128

type Output = Self

fn difference(self, rhs: Self) -> Self

impl BitDifference<Complement<u128>> for u128

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl<const N: usize> BitDifference<[u128; N]> for [u128; N]

type Output = Self

fn difference(self, rhs: Self) -> Self

impl<const N: usize> BitDifference<Complement<[u128; N]>> for [u128; N]

type Output = Self

fn difference(self, rhs: Complement<Self>) -> Self

impl BitDifference<bool> for bool

type Output = Self

impl<T, U> BitDifference<U> for Option<T> where
T: BitDifference<U>,

impl<const N: usize> BitDifference<[u8 ; N]> for [u8 ; N]

impl<const N: usize> BitDifference<Complement<[u8 ; N]>> for [u8 ; N]

impl<const N: usize> BitDifference<[u16 ; N]> for [u16 ; N]

impl<const N: usize> BitDifference<Complement<[u16 ; N]>> for [u16 ; N]

impl<const N: usize> BitDifference<[u32 ; N]> for [u32 ; N]

impl<const N: usize> BitDifference<Complement<[u32 ; N]>> for [u32 ; N]

impl<const N: usize> BitDifference<[u64 ; N]> for [u64 ; N]

impl<const N: usize> BitDifference<Complement<[u64 ; N]>> for [u64 ; N]

impl<const N: usize> BitDifference<[u128 ; N]> for [u128 ; N]

impl<const N: usize> BitDifference<Complement<[u128 ; N]>> for [u128 ; N]

impl<T, U> BitDifference<U> for Complement<T> where
T: BitUnion<U>,

impl<T, U, Y> BitDifference<Y> for Difference<T, U> where
T: BitDifference<Y>,

impl<T, U, Y> BitDifference<Y> for Intersection<T, U> where
T: BitDifference<Y>,

impl<T, U, Y> BitDifference<Y> for Union<T, U> where
T: BitDifference<Y>,
U: BitDifference<Y>,
Y: Copy,