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 != (inequality) operator is a binary infix operator in Swift that evaluates whether two instances of the same type are distinct, returning a Bool value. It is the logical negation of the equality operator (==). 
lhs != rhs

​
Protocol Mechanics

In Swift, the != operator is intrinsically tied to the Equatable protocol. For the operator to be applied to a type, both the left-hand side (lhs) and right-hand side (rhs) operands must conform to Equatable. Unlike some languages where inequality must be explicitly defined alongside equality, Swift’s Standard Library provides a default implementation for != via a protocol extension on Equatable. 
extension Equatable {
    @inlinable
    public static func != (lhs: Self, rhs: Self) -> Bool {
        return !(lhs == rhs)
    }
}
Because of this default implementation, developers implementing custom types should never implement the != operator directly. Instead, you only implement the == operator (or allow the compiler to synthesize it), and Swift automatically derives the != operator by negating the result of ==.

​
Operator Characteristics

  • Fixity: Infix (placed between two operands).
  • Precedence Group: ComparisonPrecedence (lower precedence than addition/multiplication, higher precedence than logical conjunction/disjunction).
  • Associativity: None. Because it lacks associativity, you cannot chain inequality operators in a single expression without parentheses (e.g., a != b != c will result in a compiler error).
  • Type Constraints: Self must match on both sides. Swift’s strong type system prevents the use of != between disparate types (e.g., comparing a String to an Int) unless a specific overload exists.

​
Memory and Reference Inequality

For reference types (classes), != evaluates value inequality based on the developer’s implementation of ==. It does not evaluate memory address identity. To check if two object references point to different memory allocations, Swift provides the distinct !== (not identical to) operator.
Master Swift with Deep Grasping Methodology!Learn More