Trait BitUnion 

pub trait BitUnion<Rhs = Self> {
    type Output;

    // Required method
    fn union(self, rhs: Rhs) -> Self::Output;
}

Union of bit-sets.

Required Associated Types

type Output

Required Methods

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

Returns bit-set with bits set for each index that has bit set in both of two arguments.

Implementations on Foreign Types

impl BitUnion for bool

type Output = bool

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

impl BitUnion for u8

type Output = u8

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

impl BitUnion for u16

type Output = u16

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

impl BitUnion for u32

type Output = u32

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

impl BitUnion for u64

type Output = u64

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

impl BitUnion for u128

type Output = u128

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

impl BitUnion<Complement<bool>> for bool

type Output = Complement<bool>

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

impl BitUnion<Complement<u8>> for u8

type Output = Complement<u8>

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

impl BitUnion<Complement<u16>> for u16

type Output = Complement<u16>

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

impl BitUnion<Complement<u32>> for u32

type Output = Complement<u32>

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

impl BitUnion<Complement<u64>> for u64

type Output = Complement<u64>

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

impl BitUnion<Complement<u128>> for u128

type Output = Complement<u128>

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

impl<T, U> BitUnion<U> for Option<T>

where T: BitUnion<U>, U: Into<T::Output>,

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

fn union(self, rhs: U) -> T::Output

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

type Output = Union<&T, U>

fn union(self, rhs: U) -> Union<Self, U>

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

type Output = Union<&mut T, U>

fn union(self, rhs: U) -> Union<Self, U>

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

type Output = Union<Box<T>, U>

fn union(self, rhs: U) -> Union<Self, U>

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

type Output = [u8; N]

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

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

type Output = [u16; N]

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

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

type Output = [u32; N]

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

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

type Output = [u64; N]

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

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

type Output = [u128; N]

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

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

type Output = Complement<[u8; N]>

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

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

type Output = Complement<[u16; N]>

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

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

type Output = Complement<[u32; N]>

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

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

type Output = Complement<[u64; N]>

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

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

type Output = Complement<[u128; N]>

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

Implementors

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

type Output = Union<Layered<T, B, N>, U>

impl<T, U> BitUnion<U> for Complement<T>

where T: BitDifference<U>,

type Output = Complement<<T as BitDifference<U>>::Output>

impl<T, U, Y> BitUnion<Y> for Difference<T, U>

type Output = Union<Difference<T, U>, Y>

impl<T, U, Y> BitUnion<Y> for Intersection<T, U>

where T: BitUnion<Y>, U: BitUnion<Y>, Y: Copy,

type Output = Intersection<<T as BitUnion<Y>>::Output, <U as BitUnion<Y>>::Output>

impl<T, U, Y> BitUnion<Y> for Union<T, U>

where T: BitUnion<Y>,

type Output = Union<<T as BitUnion<Y>>::Output, U>