> ## 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.
# Swift Inequality
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 (`==`).
```swift theme={"dark"}
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`.
```swift theme={"dark"}
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.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
