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 in Swift is a polymorphic, statically dispatched operator that functions primarily as a binary infix operator for arithmetic addition and collection concatenation, and secondarily as a unary prefix operator for returning the mathematical identity of an operand. Because Swift enforces strict type safety, the + operator does not perform implicit type coercion. Both the left-hand side (lhs) and right-hand side (rhs) operands must evaluate to the exact same type, or a specific overload for the mixed types must exist in the compiler’s resolution context.

​
Operator Signatures

The operator is defined in the Swift Standard Library using the following fundamental signatures: 
// Binary Infix
static func + (lhs: Self, rhs: Self) -> Self

// Unary Prefix
static prefix func + (x: Self) -> Self

​
Protocol Bindings

The behavior of the + operator is dictated by the protocols to which the operand types conform:
  • AdditiveArithmetic: For numeric types (e.g., Int, Double, UInt), the binary + operator satisfies the requirement of the AdditiveArithmetic protocol, executing standard mathematical addition. Furthermore, the unary prefix + is defined as an extension on AdditiveArithmetic. It returns the operand unmodified (+x == x) and is perfectly valid on both signed and unsigned integer types.
  • RangeReplaceableCollection: For collections (e.g., Array, String), the + operator concatenates the lhs and rhs data structures, returning a newly allocated collection containing the combined elements. The RangeReplaceableCollection protocol makes no guarantees regarding underlying memory contiguity; whether the resulting collection allocates a contiguous block of memory or utilizes a non-contiguous structure (like a chunked deque or linked list) depends entirely on the specific conforming type’s implementation.

​
Safety and Overflow Mechanics

Unlike C or Objective-C, Swift’s + operator includes mandatory, compiler-injected bounds checking for integer types. If the evaluation of lhs + rhs results in a value that exceeds the maximum or minimum representable bounds of the underlying type, the operation triggers a runtime trap (a fatal error), preventing silent integer overflow. To explicitly permit two’s-complement overflow wrapping, Swift provides the distinct &+ (overflow addition) operator.

​
Memory Semantics

The + operator is strictly non-mutating. It evaluates the operands and returns a newly initialized instance of the resulting type. It does not modify the memory state of either lhs or rhs. For in-place mutation, Swift utilizes the compound assignment operator (+=), which modifies the lhs directly and avoids the overhead of allocating a new instance when dealing with value semantics and copy-on-write (CoW) data structures.

​
Custom Implementation (Overloading)

Developers can extend the + operator for custom structures or classes by defining a static func within the type definition or an extension. 
struct Vector2D {
    var x: Double
    var y: Double
    
    static func + (lhs: Vector2D, rhs: Vector2D) -> Vector2D {
        return Vector2D(
            x: lhs.x + rhs.x, 
            y: lhs.y + rhs.y
        )
    }
}
When overloading, the operator inherits its precedence and associativity from the AdditionPrecedence group, which defines left-associativity and a lower precedence than MultiplicationPrecedence.
Master Swift with Deep Grasping Methodology!Learn More