Does Swift have a spaceship operator <=>, and if not how would a custom operator be created?

Question

From Wikipedia:

Unlike traditional equality operators, which will return true or false depending on whether the arguments are equal or unequal, the spaceship operator will return 1, 0, or −1 depending on the value of the left argument relative to the right argument. If the left argument is greater than the right argument, the operator returns 1. If the left argument is less than the right argument, the operator returns −1. If the two arguments are equal, the operator returns 0.

The spaceship operator is primarily used for comparisons in sorting.

Answer 1

Swift does not have a built-in spaceship operator, but creating new operators in swift is trivial. Let's make a new operator that returns an enum instead of an Int — magic numbers are bad and we shouldn't need to use them for the return type in a strongly typed language. While we are at it, let's take advantage of Swift's Unicode support and make the enumeration support a visual indicator of the result using ←, →, & ↔ :

enum Spaceship
{
  case ← // LeftIsGreaterThanRight
  case → // LeftIsLessThanRight
  case ↔ // LeftIsEqualToRight
}

operator infix <=> {}

@infix func <=> <T: Comparable> (left: T, right: T) -> Spaceship {
  if left < right { return SpaceShip.→}
  if left > right { return SpaceShip.←}
  return Spaceship.↔;
}

Now you can use the new operator like this

if someInt <=> someOtherInt == ←
{
  // take off!
}

If you insist on using magic numbers as a comparison result value (which I really, really encourage you not to do in Swift), then here:

@infix func <=><T: Comparable> (left: T, right: T) -> Int {
  if left < right { return -1 }
  if left > right { return  1 }
  return 0
}

Answer 2

No, Swift currently does not include a spaceship operator.

A Custom Spaceship Operator for Swift

A custom operator can be defined to mimic the look and function of spaceship operators in other languages.

The Operator

Since Swift allows the use of <, = and > characters in custom operators, we can define a custom operator to look like this: <=>.

Using the Operator

The operator is a binary infix operator and is used like this:

1 <=> 2   //Returns: -1
2 <=> 1   //Returns: 1
1 <=> 1   //Returns: 0

Defining the Operator

The operator can be defined in Swift like this:

operator infix <=> {}

@infix func <=><T: Comparable> (left: T, right: T) -> Int {
  if left < right { return -1 }
  if left > right { return  1 }
  return 0
}

Answer 3

As noted by a few ComparisonResult already exists so can be used:

extension Comparable {
    static func <=> (lhs: Self, rhs: Self) -> ComparisonResult {
        if lhs < rhs { return .orderedAscending }
        if lhs > rhs { return .orderedDescending }
        return .orderedSame
    }
}

As mentioned in the question:

The spaceship operator is primarily used for comparisons in sorting.

This is doubly true as it can even be used to implement an elegant stable sort function on top of other Sequence functions:

extension Sequence {
    func sorted(with comparator: (Element, Element) throws -> ComparisonResult) rethrows -> [Element]
    {
        return try enumerated()
            .sorted { (try comparator($0.element, $1.element) || $0.offset <=> $1.offset) == .orderedAscending }
            .map { $0.element }
    }
}

extension ComparisonResult {
    static func || (lhs: Self, rhs: @autoclosure () -> Self) -> ComparisonResult {
        if lhs == .orderedSame {
            return rhs()
        }
        return lhs
    }
}