Varadic property comparison in Swift

variadic-generics-comparable.swift

public enum SortOrder {
    case ascending
    case descending
}

@inlinable @inline(__always)
public func isLessThan<Root, each Value: Comparable>(
    _ leftRoot: Root,
    _ rightRoot: Root,
    comparing properties: repeat ((Root) -> each Value, SortOrder)
) -> Bool {

    // This should get constant-folded.
    var numProperties = 0
    for _ in repeat each properties {
        numProperties += 1
    }

    var propertyIdx = 0
    for (getProperty, mode) in repeat each properties {
        let (left, right) = (getProperty(leftRoot), getProperty(rightRoot))
        // We can save an equality check for the final element.
        if propertyIdx < numProperties {
            guard left != right else { 
                propertyIdx += 1
                continue
            }
        }
        switch mode {
        case .ascending:  return left < right
        case .descending: return left > right
        }
    }
    return false
}



// --------------------------------
// Example Usage
// --------------------------------



extension Bool: @retroactive Comparable {
  @inlinable @inline(__always)
  public static func < (lhs: Self, rhs: Self) -> Bool {
    (lhs ? 1 : 0) < (rhs ? 1 : 0)
  }  
}

struct Account: Comparable {
  var name: String
  var isActive: Bool

  static func < (lhs: Self, rhs: Self) -> Bool {
    isLessThan(
      lhs, rhs,
      comparing: (\.isActive, .descending), (\.name, .ascending)
    )
  }
}

let accounts = [
    Account(name:"Albert", isActive: false),
    Account(name:"Alice", isActive: true),
    Account(name:"Becka", isActive: false),
    Account(name:"Bob", isActive: true)
]

for a in accounts.sorted() {
    print(a)
}

// Prints:
// Account(name: "Alice", isActive: true)
// Account(name: "Bob", isActive: true)
// Account(name: "Albert", isActive: false)
// Account(name: "Becka", isActive: false)