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 View Protocol Hierarchy →
Import import Swift

Instance Methods

func <(_:rhs:) Required

A strict total order over instances of Self.

Declaration

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

Declaration

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

Returns 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