Sorting collections by multiple criteria in Swift can often lead to verbose and complex code, especially when dealing with optional properties and custom sort orders. To illustrate the improvements offered by the MultiKeyPathSort framework, let's compare traditional sorting methods with the streamlined approach provided by this package.

Traditional Approach: Sorting by Multiple Properties

Consider a Contact struct with firstName, lastName, and age properties:

struct Contact {
    var firstName: String
    var lastName: String
    var age: Int?
}

To sort an array of Contact instances first by lastName (ascending), then by firstName (ascending), and finally by age (descending), handling optional age values appropriately, you might write:

let contacts: [Contact] = // your array of contacts

let sortedContacts = contacts.sorted { (lhs, rhs) in
    if lhs.lastName != rhs.lastName {
        return lhs.lastName < rhs.lastName
    }
    if lhs.firstName != rhs.firstName {
        return lhs.firstName < rhs.firstName
    }
    return (lhs.age ?? Int.min) > (rhs.age ?? Int.min)
}

This approach requires manual comparison for each property and handling of optional values, which can be error-prone and hard to maintain.

Using MultiKeyPathSort

With MultiKeyPathSort, the same sorting can be achieved more succinctly:

import MultiKeyPathSort

let sortedContacts = contacts.sorted(using: [
    SortDescriptor(\.lastName),
    SortDescriptor(\.firstName),
    SortDescriptor(\.age, order: .reverse, nilsFirst: true)
])

Here, SortDescriptor instances define the sorting criteria: • \.lastName and \.firstName are sorted in ascending order by default. • \.age is sorted in descending order (order: .reverse), with nil values placed first (nilsFirst: true).

This method enhances code readability and reduces the potential for errors associated with manual comparisons.

In-Place Sorting

For mutable collections, MultiKeyPathSort also supports in-place sorting:

var mutableContacts: [Contact] = // your array of contacts

mutableContacts.sort(using: [
    SortDescriptor(\.lastName),
    SortDescriptor(\.firstName),
    SortDescriptor(\.age, order: .reverse, nilsFirst: true)
])

This feature allows for performance optimizations by modifying the original collection directly.

Conclusion

MultiKeyPathSort simplifies the process of sorting collections by multiple properties in Swift. It abstracts the complexity of handling optional values and custom sort orders, resulting in cleaner and more maintainable code. By leveraging key paths and sort descriptors, developers can implement sophisticated sorting logic with minimal effort.