Trait BitXor

1.0.0 · Source

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

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

Available on crate feature mtls only.

Expand description

The bitwise XOR operator ^.

Note that Rhs is Self by default, but this is not mandatory.

§Examples

An implementation of BitXor that lifts ^ to a wrapper around bool.

use std::ops::BitXor;

#[derive(Debug, PartialEq)]
struct Scalar(bool);

impl BitXor for Scalar {
    type Output = Self;

    // rhs is the "right-hand side" of the expression `a ^ b`
    fn bitxor(self, rhs: Self) -> Self::Output {
        Self(self.0 ^ rhs.0)
    }
}

assert_eq!(Scalar(true) ^ Scalar(true), Scalar(false));
assert_eq!(Scalar(true) ^ Scalar(false), Scalar(true));
assert_eq!(Scalar(false) ^ Scalar(true), Scalar(true));
assert_eq!(Scalar(false) ^ Scalar(false), Scalar(false));

An implementation of BitXor trait for a wrapper around Vec<bool>.

use std::ops::BitXor;

#[derive(Debug, PartialEq)]
struct BooleanVector(Vec<bool>);

impl BitXor for BooleanVector {
    type Output = Self;

    fn bitxor(self, Self(rhs): Self) -> Self::Output {
        let Self(lhs) = self;
        assert_eq!(lhs.len(), rhs.len());
        Self(
            lhs.iter()
                .zip(rhs.iter())
                .map(|(x, y)| *x ^ *y)
                .collect()
        )
    }
}

let bv1 = BooleanVector(vec![true, true, false, false]);
let bv2 = BooleanVector(vec![true, false, true, false]);
let expected = BooleanVector(vec![false, true, true, false]);
assert_eq!(bv1 ^ bv2, expected);

Required Associated Types§

The resulting type after applying the ^ operator.

Required Methods§

Performs the ^ operation.

assert_eq!(true ^ false, true);
assert_eq!(true ^ true, false);
assert_eq!(5u8 ^ 1u8, 4);
assert_eq!(5u8 ^ 2u8, 7);

Implementors§

Xor between 0 and 0 ( 0 ^ 0 = 0)

Xor between 1 and 1 ( 1 ^ 1 = 0)

Xor between 1 and 0 ( 1 ^ 0 = 1)

Xor between 0 and 1 ( 0 ^ 1 = 1)

Xoring unsigned integers. We use our PrivateXor operator and then Trim the output.

Trait BitXorCopy item path

§Examples

Required Associated Types§

type Output

Required Methods§

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

§Examples

Implementors§

impl BitXor for bool

type Output = bool

impl BitXor for i8

type Output = i8

impl BitXor for i16

type Output = i16

impl BitXor for i32

type Output = i32

impl BitXor for i64

type Output = i64

impl BitXor for i128

type Output = i128

impl BitXor for isize

type Output = isize

impl BitXor for u8

type Output = u8

impl BitXor for u16

type Output = u16

impl BitXor for u32

type Output = u32

impl BitXor for u64

type Output = u64

impl BitXor for u128

type Output = u128

impl BitXor for usize

type Output = usize

impl BitXor for BigInt

type Output = BigInt

impl BitXor for BigUint

type Output = BigUint

impl BitXor for Saturating<i8>

type Output = Saturating<i8>

impl BitXor for Saturating<i16>

type Output = Saturating<i16>

impl BitXor for Saturating<i32>

type Output = Saturating<i32>

impl BitXor for Saturating<i64>

type Output = Saturating<i64>

impl BitXor for Saturating<i128>

type Output = Saturating<i128>

impl BitXor for Saturating<isize>

type Output = Saturating<isize>

impl BitXor for Saturating<u8>

type Output = Saturating<u8>

impl BitXor for Saturating<u16>

type Output = Saturating<u16>

impl BitXor for Saturating<u32>

type Output = Saturating<u32>

impl BitXor for Saturating<u64>

type Output = Saturating<u64>

impl BitXor for Saturating<u128>

type Output = Saturating<u128>

impl BitXor for Saturating<usize>

type Output = Saturating<usize>

impl BitXor for Wrapping<i8>

type Output = Wrapping<i8>

impl BitXor for Wrapping<i16>

type Output = Wrapping<i16>

impl BitXor for Wrapping<i32>

type Output = Wrapping<i32>

impl BitXor for Wrapping<i64>

type Output = Wrapping<i64>

impl BitXor for Wrapping<i128>

type Output = Wrapping<i128>

impl BitXor for Wrapping<isize>

type Output = Wrapping<isize>

impl BitXor for Wrapping<u8>

type Output = Wrapping<u8>

impl BitXor for Wrapping<u16>

type Output = Wrapping<u16>

impl BitXor for Wrapping<u32>

type Output = Wrapping<u32>

Trait BitXor