Bitwise AND

The & symbol in Swift serves three distinct syntactic and semantic roles depending on its context: as a binary bitwise AND operator for integer types, as a syntactic marker for passing references or pointers to functions, and as an infix operator for protocol composition in type signatures.

1. Bitwise AND Operator

When used as an infix operator between two integer types, & performs a bitwise AND operation. It evaluates the binary representation of both operands and returns a new integer of the same type. A bit in the resulting integer is set to 1 strictly if the corresponding bits in both the left-hand side (LHS) and right-hand side (RHS) operands are 1. Otherwise, the bit is set to 0.

Syntax:

let result = lhs & rhs

Technical Characteristics:

• Associativity: Left-associative.
• Precedence: Belongs to the MultiplicationPrecedence group. Unlike C-family languages where bitwise AND has lower precedence than equality operators, Swift’s & evaluates before ComparisonPrecedence (e.g., ==) and AdditionPrecedence (e.g., |, ^). Consequently, an expression like 1 | 2 & 0 evaluates as 1 | (2 & 0), and lhs & rhs == 0 evaluates as (lhs & rhs) == 0.
• Type Constraints: Both operands must conform to the BinaryInteger protocol and be of the exact same type.

Execution:

let lhs: UInt8 = 0b11001100 // Decimal: 204
let rhs: UInt8 = 0b10101010 // Decimal: 170

let result = lhs & rhs      // 0b10001000 (Decimal: 136)

// Precedence evaluation
let isZero = lhs & rhs == 0 // Evaluates as (lhs & rhs) == 0

2. In-Out Expression Marker

When used as a prefix at a function call site, & functions strictly as a syntactic marker (parsed grammatically as an in-out-expression), not as a prefix operator. It denotes that a variable is being passed as a reference or a pointer rather than by value. Because it is a marker and not an operator, it does not participate in operator precedence, cannot be overloaded, and Swift explicitly forbids defining & as a custom prefix operator.

Syntax:

functionName(&variable)

Technical Characteristics:

• In-Out Parameters: When bound to an inout parameter, & invokes Swift’s “copy-in copy-out” (call-by-value-result) memory model. The value is copied upon invocation, mutated locally, and copied back to the original memory location upon return.
• Implicit Pointer Conversion: When passed to a function expecting an UnsafePointer<T> or UnsafeMutablePointer<T>, & yields the memory address of the variable. Passing via & does not inherently grant mutation rights; if the parameter is UnsafePointer<T>, the memory is strictly immutable.
• Mutability Constraints: The operand prefixed by & must be a mutable variable (declared with var), regardless of whether the receiving function mutates the memory or reads it immutably via an UnsafePointer. It cannot be a constant (let), a literal, or a computed property lacking a setter.
• Exclusivity: Swift’s Law of Exclusivity dictates that passing a variable via & requires exclusive access to that variable’s memory for the duration of the function call, preventing concurrent access traps.

Execution:

// 1. Binding to an inout parameter (mutation permitted)
func increment(value: inout Int) { value += 1 }
var counter = 0
increment(value: &counter)

// 2. Binding to an UnsafePointer (strictly immutable)
func readPointer(_ ptr: UnsafePointer<Int>) { /* ... */ }
var readOnlyTarget = 42
readPointer(&readOnlyTarget) 

3. Protocol Composition Operator

When used as an infix operator within a type signature, & performs protocol composition. It combines multiple protocols (and optionally up to one class) into a single requirement, representing an existential type or a generic constraint that must conform to all specified types simultaneously.

Syntax:

TypeA & TypeB

Technical Characteristics:

• Type Intersection: The operator does not create a new concrete type at runtime. Instead, it creates a compile-time intersection of type requirements.
• Constraints: The composition can include any number of protocols but is restricted to a maximum of one class type.
• Contexts: It is strictly a type-level operator used in variable declarations, function parameters, generic where clauses, and typealias definitions.

Execution:

protocol Renderable { /* ... */ }
protocol Animatable { /* ... */ }

// Typealias composition
typealias InteractiveNode = Renderable & Animatable

// Generic constraint composition using standard library protocols
func process<T: Sequence & Identifiable>(item: T) { /* ... */ }

// Existential type composition in a variable declaration
var handler: any Hashable & Sendable

Master Swift with Deep Grasping Methodology!

Learn More