> ## 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 Overflow Subtraction
The `&-` operator is Swift's overflow subtraction operator. It performs integer subtraction while explicitly permitting the result to underflow the minimum bound of the given integer type. Instead of triggering a runtime trap (crash) upon underflow, the `&-` operator wraps the result around to the maximum representable values of that type using two's complement arithmetic.
## Syntax
```swift theme={"dark"}
let result = leftOperand &- rightOperand
```
## Mechanics and Behavior
In Swift, standard arithmetic operators (like `-`) are strictly bounds-checked. If a subtraction operation results in a value smaller than the type's `min` property, the Swift standard library raises a fatal error. The `&-` operator bypasses this bounds-checking mechanism.
When an underflow occurs using `&-`, the operation discards the borrow bit that extends beyond the available bit width of the integer type. The resulting bit pattern is interpreted according to whether the type is signed or unsigned.
### Unsigned Integer Wrapping
For unsigned integers, subtracting past `0` wraps around to the maximum value of that specific type (`UInt.max`).
```swift theme={"dark"}
let unsignedMin: UInt8 = 0
// Standard subtraction (unsignedMin - 1) would trap here.
let wrappedUnsigned = unsignedMin &- 1
// Binary representation:
// 00000000 (0)
// - 00000001 (1)
// = 11111111 (255)
print(wrappedUnsigned) // Outputs: 255
```
### Signed Integer Wrapping
For signed integers, subtracting past the type's minimum value (`Int.min`) wraps around to the maximum positive value of that type (`Int.max`).
```swift theme={"dark"}
let signedMin: Int8 = -128
// Standard subtraction (signedMin - 1) would trap here.
let wrappedSigned = signedMin &- 1
// Binary representation (Two's complement):
// 10000000 (-128)
// - 00000001 (1)
// = 01111111 (127)
print(wrappedSigned) // Outputs: 127
```
## Type Constraints
The `&-` operator is defined exclusively for types conforming to the `FixedWidthInteger` protocol. It cannot be used with floating-point types (`Float`, `Double`), as floating-point numbers handle boundary conditions using IEEE 754 standards (such as `-Infinity` or `NaN`) rather than bitwise wrapping.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
