Trait std::ops::BitAnd1.0.0 [] [src]

#[lang = "bitand"]
pub trait BitAnd<RHS = Self> { type Output; fn bitand(self, rhs: RHS) -> Self::Output; }

The bitwise AND operator &.

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


An implementation of BitAnd for a wrapper around bool.

use std::ops::BitAnd;

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

impl BitAnd for Scalar {
    type Output = Self;

    // rhs is the "right-hand side" of the expression `a & b`
    fn bitand(self, rhs: Self) -> Self {
        Scalar(self.0 & rhs.0)

assert_eq!(Scalar(true) & Scalar(true), Scalar(true));
assert_eq!(Scalar(true) & Scalar(false), Scalar(false));
assert_eq!(Scalar(false) & Scalar(true), Scalar(false));
assert_eq!(Scalar(false) & Scalar(false), Scalar(false));Run

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

use std::ops::BitAnd;

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

impl BitAnd for BooleanVector {
    type Output = Self;

    fn bitand(self, BooleanVector(rhs): Self) -> Self {
        let BooleanVector(lhs) = self;
        assert_eq!(lhs.len(), rhs.len());
        BooleanVector(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![true, false, false, false]);
assert_eq!(bv1 & bv2, expected);Run

Associated Types

The resulting type after applying the & operator.

Required Methods

Performs the & operation.