## Comparable

`protocol Comparable`

Instances of conforming types can be compared using relational operators, which define a strict total order.

A type conforming to `Comparable` need only supply the `<` and `==` operators; default implementations of `<=`, `>`, `>=`, and `!=` are supplied by the standard library:

``````struct Singular : Comparable {}
func ==(x: Singular, y: Singular) -> Bool { return true }
func <(x: Singular, y: Singular) -> Bool { return false }``````

Axioms, in addition to those of `Equatable`:

• `x == y` implies `x <= y`, `x >= y`, `!(x < y)`, and `!(x > y)`
• `x < y` implies `x <= y` and `y > x`
• `x > y` implies `x >= y` and `y < x`
• `x <= y` implies `y >= x`
• `x >= y` implies `y <= x`
Inheritance `Equatable, _Comparable` View Protocol Hierarchy → `import Swift`

### Instance Methods

func <(_:rhs:) Required

A strict total order over instances of `Self`

#### Declaration

`func <(lhs: Self, rhs: Self) -> Bool`

#### Declared In

`_Comparable`
func <=(_:rhs:)

#### Declaration

`func <=(lhs: Self, rhs: Self) -> Bool`
func ==(_:rhs:) Required

Return true if `lhs` is equal to `rhs`.

Equality implies substitutability. When `x == y`, `x` and `y` are interchangeable in any code that only depends on their values.

Class instance identity as distinguished by triple-equals `===` is notably not part of an instance's value. Exposing other non-value aspects of `Equatable` types is discouraged, and any that are exposed should be explicitly pointed out in documentation.

Equality is an equivalence relation

• `x == x` is `true`
• `x == y` implies `y == x`
• `x == y` and `y == z` implies `x == z`

Inequality is the inverse of equality, i.e. `!(x == y)` iff `x != y`

#### Declaration

`func ==(lhs: Self, rhs: Self) -> Bool`

#### Declared In

`Equatable`
func >(_:rhs:)

#### Declaration

`func >(lhs: Self, rhs: Self) -> Bool`
func >=(_:rhs:)

#### Declaration

`func >=(lhs: Self, rhs: Self) -> Bool`