# [swift-evolution] sortBy, minElementBy and maxElementBy methods

Dave Abrahams dabrahams at apple.com
Thu Dec 31 01:53:02 CST 2015

```Why add all those algorithms when you can write this

func byComparing<T, U: Comparable>(getComparisonKey: (T)->U) -> (T, T) -> Bool {
return { getComparisonKey(\$0) < getComparisonKey(\$1) }
}

peoples.sort(byComparing { \$0.name })

?

-Dave

> On Dec 30, 2015, at 10:38 PM, Susan Cheng via swift-evolution <swift-evolution at swift.org> wrote:
>
>
> 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.
>     ///
>     /// - Complexity: O(`elements.count`).
>     ///
>     @warn_unused_result
>     public func minElement<R : Comparable>(@noescape by: (Generator.Element) throws -> R) rethrows -> Generator.Element? {
>         return try self.minElement { try by(\$0) < by(\$1) }
>     }
>     /// Returns the maximum element in `self` or `nil` if the sequence is empty.
>     ///
>     /// - Complexity: O(`elements.count`).
>     ///
>     @warn_unused_result
>     public func maxElement<R : Comparable>(@noescape by: (Generator.Element) throws -> R) rethrows -> Generator.Element? {
>         return try self.maxElement { try by(\$0) < by(\$1) }
>     }
> }
>
> public extension MutableCollectionType {
>
>     /// Return an `Array` containing the sorted elements of `source`.
>     /// according to `by`.
>     ///
>     /// The sorting algorithm is not stable (can change the relative order of
>     /// elements that compare equal).
>     @warn_unused_result(mutable_variant="sortInPlace")
>     func sort<R : Comparable>(@noescape by: (Generator.Element) -> R) -> [Generator.Element] {
>         return self.sort { by(\$0) < by(\$1) }
>     }
> }
>
> public extension MutableCollectionType where Self.Index : RandomAccessIndexType {
>
>     /// Sort `self` in-place according to `by`.
>     ///
>     /// The sorting algorithm is not stable (can change the relative order of
>     /// elements that compare equal).
>     mutating func sortInPlace<R : Comparable>(@noescape by: (Generator.Element) -> R) {
>         self.sortInPlace { by(\$0) < by(\$1) }
>     }
> }
>
>  _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20151230/4b87b538/attachment.html>
```