> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Rust Bitwise AND Assignment
The `&=` operator is a compound assignment operator that performs a bitwise AND operation (or logical AND for booleans) between a mutable left-hand side (LHS) operand and a right-hand side (RHS) operand, updating the LHS operand in place with the result.
Unlike some languages where `lhs &= rhs` is syntactic sugar for `lhs = lhs & rhs`, Rust treats compound assignment as a distinct operation. The `&=` operator desugars directly to a method call on the `std::ops::BitAndAssign` trait.
```rust theme={"dark"}
// Standard syntax
lhs &= rhs;
// Desugared equivalent
std::ops::BitAndAssign::bitand_assign(&mut lhs, rhs);
```
This distinction is critical in Rust's ownership and type system:
* **Borrowing vs. Moving:** `lhs &= rhs` only borrows `lhs` mutably. Conversely, `lhs = lhs & rhs` consumes (moves) `lhs` if the type does not implement the `Copy` trait.
* **Trait Independence:** A type can implement `BitAndAssign` without implementing the `BitAnd` trait. Therefore, `lhs &= rhs` can be perfectly valid even when `lhs = lhs & rhs` results in a compiler error.
## Technical Mechanics
At the bit level, the operator compares each corresponding bit of the LHS and RHS operands. If both bits are `1`, the resulting bit is `1`. Otherwise, the resulting bit is `0`.
When applied to boolean types (`bool`), `&=` functions as a logical AND assignment, evaluating to `true` only if both the current LHS value and the RHS value are `true`.
The LHS variable must be explicitly declared as mutable (`mut`) for the compiler to allow the assignment.
```rust theme={"dark"}
// Integer bitwise AND assignment
let mut a: u8 = 0b1100_1100;
let b: u8 = 0b1010_1010;
a &= b;
assert_eq!(a, 0b1000_1000);
// Boolean AND assignment
let mut flag = true;
flag &= false;
assert_eq!(flag, false);
```
## Trait Implementation
The Rust standard library implements the `BitAndAssign` trait for all primitive integer types and booleans.
To use `&=` with custom structs or enums, you must explicitly implement `std::ops::BitAndAssign` for your type. The trait requires the implementation of a single method, `bitand_assign`, which takes a mutable reference to `self` and consumes the RHS operand.
```rust theme={"dark"}
use std::ops::BitAndAssign;
#[derive(Debug, PartialEq)]
struct BitVector(u16);
impl BitAndAssign for BitVector {
fn bitand_assign(&mut self, rhs: Self) {
// Mutate self in place
self.0 &= rhs.0;
}
}
let mut v1 = BitVector(0b1111);
let v2 = BitVector(0b0101);
v1 &= v2;
assert_eq!(v1, BitVector(0b0101));
```
Tired of Poor Rust Skills? Fix That With Deep Grasping!
Learn More
