Bitwise AND

The & operator in Rust serves two distinct semantic purposes depending on its syntactic context: it acts as the reference operator for memory borrowing and type declaration, and as the bitwise AND operator for integer arithmetic.

1. The Reference Operator (Borrowing)

In the context of memory management and ownership, & creates a shared, immutable reference to a value. It allows a binding to point to data without taking ownership of it. The Rust compiler’s borrow checker ensures that references created with & are always valid and do not outlive the data they point to.

Expression Context: When applied to an expression, & evaluates to a memory address (pointer) with strict aliasing and lifetime guarantees. If x is of type T, the expression &x yields a value of type &T.

let x: i32 = 10;
let ref_x: &i32 = &x; // Evaluates to a reference pointing to the memory location of x

Type Context: When used in a type signature, & denotes a reference type. It can optionally be annotated with an explicit lifetime parameter to define the lexical scope of the reference’s validity.

// Implicit lifetime
fn process(data: &String) -> &str { 
    unimplemented!() 
}

// Explicit lifetime
fn process_with_lifetime<'a>(data: &'a String) -> &'a str { 
    unimplemented!() 
}

Pattern Context (Destructuring): When used in a pattern (such as the left side of a let statement or a match arm), & performs the inverse operation of the reference expression. It destructures a reference, stripping away the pointer indirection to bind the underlying value.

Crucially, destructuring a reference to bind the underlying value requires the underlying type to implement the Copy trait. If the type does not implement Copy (e.g., a String), this syntax will cause a compiler error (“cannot move out of a shared reference”). This restriction enforces Rust’s ownership model, preventing a developer from moving a value out of a borrowed state.

let reference: &i32 = &42;
let &value = reference; // 'value' is bound as type i32. Valid because i32 implements Copy.

2. The Bitwise AND Operator

In an arithmetic context, & performs a bitwise AND operation between two operands. It compares each bit of the first operand to the corresponding bit of the second operand, returning 1 if both bits are 1, and 0 otherwise.

At the language level, this behavior is governed by the std::ops::BitAnd trait. Any type implementing this trait can be used with the & operator in an infix position.

let a: u8 = 0b1100_1100;
let b: u8 = 0b1010_1010;
let result: u8 = a & b; // Evaluates to 0b1000_1000

When combined with the assignment operator (&=), it performs the bitwise AND operation and assigns the result to the left operand, governed by the std::ops::BitAndAssign trait.

let mut flags: u8 = 0b1111;
flags &= 0b0011; // flags is now 0b0011

Master Rust with Deep Grasping Methodology!

Learn More