Swift Bitwise Left Shift

let result = leftOperand << rightOperand

​

Technical Mechanics

1. Displacement: Every bit in the leftOperand is moved to the left by the number of positions defined by the rightOperand.
2. Zero Extension: The vacated bit positions on the least significant bit (LSB) side (the right side) are filled with zeros.
3. Truncation: Any bits shifted beyond the bounds of the most significant bit (MSB) for the integer’s specific type width (e.g., beyond the 8th bit in a UInt8) are permanently discarded.

​

Smart Shift Semantics

• Over-shifting: If the shift amount is greater than or equal to the bit width of the leftOperand, the operator evaluates to 0. All original bits are safely shifted out of bounds.
• Negative Shifting: If the shift amount is less than 0, the operator reverses direction. A negative left shift safely performs a right shift (>>) by the absolute value of the shift amount.

​

Syntax and Type Constraints

static func << <RHS: BinaryInteger>(lhs: Self, rhs: RHS) -> Self

• Return Type: The resulting value retains the exact type of the leftOperand (Self).
• Protocol Conformance: Both operands must conform to the BinaryInteger protocol. However, they are not required to be the exact same type. The right-hand operand (RHS) can be any type conforming to BinaryInteger, allowing you to shift an Int64 by an Int8, for example.

​

Bitwise Visualization

let initialValue: UInt8 = 0b0001_0111 
let shiftedValue = initialValue << 3   

// Bit-level transformation:
// [0 0 0 1 0 1 1 1] (initialValue)
//  \ \ \ \ \ \ \ \
//   \ \ \ \ \ \ \ \
// [1 0 1 1 1 0 0 0] (shiftedValue)

let value: UInt8 = 0b1111_1111

// Over-shifting (>= 8 bits for UInt8) evaluates to 0
let overShifted = value << 10 
// Result: 0b0000_0000

// Negative shifting reverses direction (acts as >> 2)
let negativeShifted = value << -2 
// Result: 0b0011_1111

​

Signed Integer Behavior

let signedValue: Int8 = 0b0011_0000 // Positive 48
let shiftedSigned = signedValue << 2

// Bit-level transformation:
// [0 0 1 1 0 0 0 0] (signedValue)
// [1 1 0 0 0 0 0 0] (shiftedSigned - MSB is now 1, resulting in Negative 64)