Skip to main content

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.

The &<< operator is the masking bitwise left shift operator in Swift. It shifts the binary representation of an integer to the left by a specified number of bits. Unlike the standard bitwise left shift operator (<<), which triggers a runtime trap on negative shift amounts and returns 0 when the shift amount is greater than or equal to the type’s bit width, &<< masks the shift amount. This guarantees a valid operation without runtime traps and causes overshifts to wrap cyclically.

​
Syntax

let result = value &<< shiftAmount

​
Masking Mechanics

When evaluating lhs &<< rhs, Swift does not directly shift lhs by rhs. Instead, it calculates an effective shift amount by performing a bitwise AND operation between the shift amount (rhs) and one less than the bit width of the value being shifted (lhs.bitWidth - 1). Because Swift’s integer types always have bit widths that are powers of two (8, 16, 32, 64), this masking operation effectively constrains the shift amount to the strict range of 0..<(lhs.bitWidth). Formula: Effective Shift = rhs & (lhs.bitWidth - 1)

​
Evaluation Examples

​
1. Standard Shift (Shift amount < Bit Width)

When the shift amount is positive and strictly less than the bit width, &<< behaves identically to <<. 
let base: UInt8 = 0b0000_0001 // Bit width is 8
let shift: UInt8 = 2

// Effective shift: 2 & (8 - 1) -> 2 & 7 -> 2
let result = base &<< shift 
// result == 0b0000_0100 (4)

​
2. Overshift (Shift amount >= Bit Width)

When the shift amount exceeds the bit width, the standard << operator performs a “smart shift” and evaluates to 0. The &<< operator instead masks the value, effectively wrapping the shift amount. 
let base: UInt8 = 0b0000_0001 // Bit width is 8
let overShift: UInt8 = 10

// Effective shift: 10 & (8 - 1) -> 10 & 7 -> 2
let result = base &<< overShift 
// result == 0b0000_0100 (4)

​
3. Exact Bit Width Shift

Shifting by the exact bit width results in an effective shift of zero, leaving the original value unchanged. 
let base: UInt8 = 0b0000_0011
let exactShift: UInt8 = 8

// Effective shift: 8 & (8 - 1) -> 8 & 7 -> 0
let result = base &<< exactShift 
// result == 0b0000_0011 (3)

​
4. Negative Shift Amounts

If the right-hand side (rhs) is a signed integer and evaluates to a negative number, the standard << operator triggers a fatal error. The &<< operator prevents this by masking the two’s complement binary representation of that negative number against bitWidth - 1. It does not reverse the direction to a right shift. 
let base: UInt8 = 0b0000_0001
let negativeShift: Int8 = -2 // Two's complement: 1111_1110

// Effective shift: -2 & 7 -> 6
let result = base &<< negativeShift
// result == 0b0100_0000 (64)
Master Swift with Deep Grasping Methodology!Learn More