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 statically dispatched, strongly typed binary infix operator primarily used for arithmetic addition and collection concatenation. It also functions as a unary prefix operator that returns the unmodified value of its operand. While default arithmetic implementations typically require the left-hand side (lhs) and right-hand side (rhs) operands to share the same type, Swift’s operator overloading fully supports mixed-type implementations. The standard library and Foundation frequently utilize mixed-type + operators, such as adding a Substring to a String, or an Int to an UnsafePointer<T>.

​
Protocol Requirements and Implementation

Under the hood, the + operator is not a hardcoded compiler primitive. For numeric types (e.g., Int, Double, Float), it is defined as a static method requirement within the AdditiveArithmetic standard library protocol: 
static func + (lhs: Self, rhs: Self) -> Self
For non-arithmetic types, such as strings and collections, + is not a protocol requirement. Instead, concatenation behavior is provided via generic global functions or protocol extensions constrained to specific types (like RangeReplaceableCollection or StringProtocol).

​
Precedence and Associativity

The binary + operator belongs to the AdditionPrecedence group.
  • Associativity: Left-associative. When multiple + operators appear in sequence, they are evaluated from left to right.
  • Precedence: It evaluates after MultiplicationPrecedence operators (like * and /) and before AssignmentPrecedence operators (like the compound assignment operators += or -=). Note that the basic assignment operator (=) is a special language token and does not belong to a precedence group.

​
Overflow Behavior

By default, Swift’s arithmetic + operator performs overflow checking. If the evaluation of the addition exceeds the maximum or minimum representable bounds of the underlying type, the operation will trigger a runtime trap (a fatal error), preventing undefined behavior. To perform two’s-complement wrapping addition without trapping, Swift provides the distinct overflow addition operator (&+): 
// Using a variable to bypass the compiler's static constant evaluator
var a: UInt8 = 255

// Standard addition (Traps at runtime due to overflow)
// let b = a + 1 

// Wrapping addition (Returns 0)
let c = a &+ 1

​
Operator Overloading

Developers can overload the + operator for custom types. Swift language rules require that operators declared within a type be defined as static methods. This ensures the operator does not take an implicit self instance parameter, maintaining symmetry between the left and right operands for binary operators and matching the signature of global operator functions. If a custom type conforms to AdditiveArithmetic, implementing this operator (along with - and zero) fulfills the protocol’s core requirements. Developers can also define mixed-type overloads by specifying different types for the lhs and rhs parameters. 
struct Vector {
    var x: Int
    var y: Int

    static func + (lhs: Vector, rhs: Vector) -> Vector {
        return Vector(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
    }
}

​
Unary Prefix Form

The + operator is also defined as a prefix operator. For types conforming to AdditiveArithmetic—which includes both signed and unsigned numeric types (e.g., Int, UInt8)—it acts as an identity operation, returning the value unchanged. It exists primarily for syntactic symmetry with the unary minus (-) operator. Like all operators defined within a type or protocol, it must be declared as a static method: 
static prefix func + (x: Self) -> Self
Master Swift with Deep Grasping Methodology!Learn More