Swift中Comparable协议为何要求实现<方法？替换为>报错原因

Let's break down exactly what's happening here, step by step:

First, Understand the Rules of the Comparable Protocol #

• Comparable inherits from Equatable—so any type conforming to Comparable must also satisfy Equatable's requirement (implementing the == operator).
• Most importantly: Comparable requires you to implement the < operator specifically. All other comparison operators (>, <=, >=) are provided as default extensions built on top of < and ==—you don't need to write them yourself.

Why Your First Implementation Worked #

When you implemented the < operator:

• For the Equatable requirement: Since your Test class's only stored property (count) is an Int (which already conforms to Equatable), Swift's compiler automatically synthesizes the == operator for you behind the scenes. You don't have to write it manually, so Equatable's rule is satisfied.
• For the Comparable requirement: You implemented the mandatory < operator, so the protocol is fully conformed to, and your code compiles without issues.

Why Replacing < with > Causes Errors #

When you swapped out < for >:

• First and foremost: Comparable doesn't care about the > operator—it needs the < operator to exist. Since you removed the required < implementation, the compiler throws a core error saying Test doesn't conform to Comparable.
• The "does not conform to protocol 'Equatable'" message is a secondary, derived error. Because Comparable depends on Equatable, the compiler's first failure (missing <) makes it fall back to checking all parent protocol requirements, even though the real issue is the missing < operator.
• Even if you write a custom > operator, the compiler won't automatically infer the < logic from it—Comparable's contract is fixed around using < as the base comparison.

The Correct Fix (If You Want lhs.count > rhs.count as Your Logic) #

If your goal is to have Test instances compare such that a higher count means the instance is "smaller" (like your original < implementation did), you don't need to replace < with > at all. Just keep the < implementation, and Comparable will automatically generate all other comparison operators for you:

extension Test: Comparable { 
    static func <(lhs: Test, rhs: Test) -> Bool { 
        return lhs.count > rhs.count 
    }
    
    // Optional: Write a custom == if you need it, otherwise the compiler synthesizes this automatically
    static func ==(lhs: Test, rhs: Test) -> Bool {
        return lhs.count == rhs.count
    }
}

You can then use all comparison operators as expected:

let test1 = Test(count: 5)
let test2 = Test(count: 3)
print(test1 < test2) // Prints true (since 5 > 3 matches our custom logic)
print(test1 > test2) // Prints false (automatically derived from <)

内容的提问来源于stack exchange，提问作者Murad Sofiyev