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 == (equality) operator is a binary infix operator that evaluates whether two operands are semantically equivalent, returning a Bool. In Swift, == is fundamentally a standard operator that can be overloaded as a static or global function. It is not strictly bound to a specific protocol, nor does it inherently require its operands to be of the exact same type.

​
Operator Overloading

Developers can define the == operator for any type without conforming to any protocols. It can be implemented to compare instances of the same type, or it can be overloaded to compare two entirely distinct types. 
struct TypeA { let value: Int }
struct TypeB { let value: Int }

// Global overload comparing two different types
func == (lhs: TypeA, rhs: TypeB) -> Bool {
    return lhs.value == rhs.value
}

​
The Equatable Protocol

While == can be implemented independently, conforming to the Equatable protocol standardizes equality checks across the language. Conformance is required to satisfy generic constraints (such as using Array.contains(_:)) and to inherit the default implementation of the != (inequality) operator. 
protocol Equatable {
    static func == (lhs: Self, rhs: Self) -> Bool
}
When a type conforms to Equatable, it must implement == as a static method where both the left-hand side (lhs) and right-hand side (rhs) operands are of the conforming type (Self).

​
Compiler Synthesis

The Swift compiler can automatically synthesize the implementation of the == operator for structs and enums, eliminating the need for manual implementation. For enums without associated values, the compiler automatically applies Equatable conformance and synthesizes the == operator without requiring any explicit declaration from the developer. For structs and enums with associated values, the developer must explicitly declare conformance to Equatable in the original type declaration or in an extension within the same file to trigger synthesis. Additionally, the following conditions must be met:
  • Structs: All stored properties must conform to Equatable.
  • Enums: All associated values must conform to Equatable.
// Implicit conformance and synthesis (no explicit declaration needed)
enum Direction {
    case north, south, east, west
}

// Explicit conformance triggers compiler synthesis
struct Matrix: Equatable {
    let rows: Int
    let columns: Int
    let grid: [Double]
}
When synthesis occurs, the compiler generates a memberwise equality check, evaluating lhs.property == rhs.property sequentially for all stored properties or associated values.

​
Tuple Equality

Tuples in Swift cannot conform to protocols, meaning a tuple can never conform to Equatable. However, tuples still support the == operator. As of Swift 5.9, the Swift standard library utilizes parameter packs to provide a single variadic generic == operator that evaluates tuples of any arity. This operator requires that all elements within the tuples are themselves Equatable and that both tuples have identical types and structures.

​
Value Equality vs. Identity

The == operator evaluates value equality (semantic equivalence), which is distinct from reference equality (identity). For reference types (classes), two distinct instances residing at different memory addresses can evaluate to true using == if their internal states match the logic defined in their == implementation. To evaluate whether two references point to the exact same memory allocation, Swift provides the === (identity) operator, which is tied to the AnyObject constraint rather than the Equatable protocol.

​
Negation

For types conforming to Equatable, the != (inequality) operator is automatically provided via a protocol extension. It is implemented by default as the logical negation of the == operator. Types that implement == without conforming to Equatable do not receive this default implementation and must implement != manually if inequality checks are required. 
extension Equatable {
    static func != (lhs: Self, rhs: Self) -> Bool {
        return !(lhs == rhs)
    }
}
Master Swift with Deep Grasping Methodology!Learn More