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

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).

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).

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.

Master Swift with Deep Grasping Methodology!

Learn More