Sort(by:) min(by:) max(by:) with keyPaths

[lovee (Elvis Shi)]

4 years ago there was a similar discussion:

sortBy, minElementBy and maxElementBy methods

Consider the follows: struct Person {     var name: String     var age: Int } let peoples = [Person(name: "Hawk", age: 24), Person(name: "Andrew", age: 23 )] let youngest = peoples.minElement { $0.age < $1.age } print(youngest?.name) it's silly that we always have to write the code like { $0.some < $1.some } or { some($0) < some($1) } so, we should add those methods to stdlib: extension SequenceType {     /// Returns the minimum element in `self` or `nil` if the sequence is empty. …

Now 4 years passed and now we've got the new KeyPath feature, but we still don't have a convenient method to sort a sequence, or get the max / min element by its elements' properties

For example currently if we want to get the greatest element from a sequence according to a property of its elements, with the standard library the only way is to write a customized closure to compare 2 elements like this:

let max = sequence.max(by: { $0.property < $1.property })

Apart from inconvenience, there are 2 major issues with the API from my perspective:

1. The purpose of the closure's return value is not clear, which conflicts with Swift's fundamental API Design Guidelines. What does the Bool return value mean? If you can come up with the idea that it's sorting the array and it will return the last element of the array as the max value, then maybe you can somehow get the idea of "sorting the sequence, by returning true if $0's property is less than $1's property", but most people who tried their first time don't.

2. Duplicates of information, which mis-typing could easily cause bugs. For example:

   let max = sequence.max(by: { x, y in x.a < x.a })

   let max = sequence.max(by: { x, y in x.a < y.b })

Both statements above are logically bugs, but they can't be checked at build time, which means it's not safe, and it conflicts with Swift's safety goal.

And since we already have keyPath feature in Swift, why couldn't we write statements like below?

let max = sequence.max(by: \.property)

This is much safer, much more clear, and much more developer-friendly comparing with existing methods.

Also, if we could have a method like

let max = sequence.max(by: { $0.getSomeValue(from: anotherData) })

then it could also be very convenient.

[Jumhyn (Frederick Kellison-Linn)]

This idea was discussed most comprehensively in this pitch:

Map Sorting

Map Sorting Authors: Anthony Latsis, Cal Stephens Status: Awaiting Review Implementation: apple/swift#23156 Introduction This proposal presents an addition to the Standard Library that makes it easy to sort a collection over some set of mapped values, provided via a transform closure or KeyPath, in a way that is ergonomic, idiomatic, and performant. Motivation To sort a Collection, you're currently required to specify an areInIncreasingOrder predicate of the form (Element, Element) -> B…

At the bottom, the authors summarize some guidance from Ben Cohen regarding the path forward for sorting-related proposals. It would be good for any further discussion of this topic to pick up from there, and how/if things have changed in the past year, and what the next steps should be for considering sorting issues more broadly!

[lovee (Elvis Shi)]

Thanks! I searched the forum with min max keywords but I missed sorted