> ## 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.
# Swift Masking Left Shift Assignment
The `&<<=` (masking bitwise left shift assignment) operator first masks a requested shift amount to ensure it remains within the bit-width limits of the data type, shifts the bit pattern of a mutable integer variable to the left by that masked amount, and then assigns the resulting value back to the original variable.
```swift theme={"dark"}
lhs &<<= rhs
```
## Technical Mechanics
* **`lhs` (Left-Hand Side):** A mutable variable of a type that conforms to the `FixedWidthInteger` protocol.
* **`rhs` (Right-Hand Side):** The requested number of bit positions to shift.
* **Masking (`&`):** The operator automatically applies a bitmask to the `rhs` *before* the shift occurs, constraining the shift amount to the bit width of the `lhs`.
* **Assignment (`=`):** This is a compound assignment operator; it mutates the `lhs` in place and evaluates to `Void` (`()`).
## Masking Calculation
The actual shift amount applied to the `lhs` is determined by a bitwise AND operation between the `rhs` and the bit width of the `lhs` minus one:
`actual_shift = rhs & (lhs.bitWidth - 1)`
For example, if `lhs` is an `UInt8` (which has a bit width of 8), the mask applied to the shift amount is `7` (binary `00000111`). If you attempt to shift an `UInt8` by `10` positions, the operator masks the `10` (`00001010`) with `7` (`00000111`), resulting in an actual shift of `2` positions.
## Syntax Visualization
```swift theme={"dark"}
var bitPattern: UInt8 = 0b0000_0011 // Decimal 3
// Attempting to shift by 10.
// Masking calculation: 10 & (8 - 1) = 10 & 7 = 2.
// The actual operation performed is a left shift by 2.
bitPattern &<<= 10
// 0b0000_0011 shifted left by 2 becomes 0b0000_1100 (Decimal 12)
print(bitPattern) // Prints 12
var negativeShiftPattern: UInt8 = 0b0000_0001 // Decimal 1
// Attempting to shift by -1.
// Masking calculation: -1 (11111111 in 8-bit two's complement) & 7 = 7.
// The actual operation performed is a left shift by 7.
negativeShiftPattern &<<= -1
// 0b0000_0001 shifted left by 7 becomes 0b1000_0000 (Decimal 128)
print(negativeShiftPattern) // Prints 128
```
*Note:* In Swift, the standard left shift assignment operator (`<<=`) performs a "smart shift." If the shift amount is greater than or equal to the type's bit width, `<<=` assigns `0` to the variable. Additionally, the standard shift operator triggers a runtime error (trap) if the shift amount is *negative*. The `&<<=` operator exists specifically to provide a wrapping masking behavior for the shift amount. This bypasses the zeroing effect when the requested shift exceeds the type's bit width, and it prevents the negative shift trap by safely masking the two's complement representation of a negative shift amount into a valid positive shift.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
