Instance MethodSwift


    Sorts the collection in place, using the given predicate as the comparison between elements.

    mutating func sort(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows



    A predicate that returns true if its first argument should be ordered before its second argument; otherwise, false. If areInIncreasingOrder throws an error during the sort, the elements may be in a different order, but none will be lost.


    When you want to sort a collection of elements that don’t conform to the Comparable protocol, pass a closure to this method that returns true when the first element should be ordered before the second.

    In the following example, the closure provides an ordering for an array of a custom enumeration that describes an HTTP response. The predicate orders errors before successes and sorts the error responses by their error code.

    enum HTTPResponse {
        case ok
        case error(Int)
    var responses: [HTTPResponse] = [.error(500), .ok, .ok, .error(404), .error(403)]
    responses.sort {
        switch ($0, $1) {
        // Order errors by code
        case let (.error(aCode), .error(bCode)):
            return aCode < bCode
        // All successes are equivalent, so none is before any other
        case (.ok, .ok): return false
        // Order errors before successes
        case (.error, .ok): return true
        case (.ok, .error): return false
    // Prints "[.error(403), .error(404), .error(500), .ok, .ok]"

    Alternatively, use this method to sort a collection of elements that do conform to Comparable when you want the sort to be descending instead of ascending. Pass the greater-than operator (>) operator as the predicate.

    var students = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]
    students.sort(by: >)
    // Prints "["Peter", "Kweku", "Kofi", "Akosua", "Abena"]"

    areInIncreasingOrder must be a strict weak ordering over the elements. That is, for any elements a, b, and c, the following conditions must hold:

    • areInIncreasingOrder(a, a) is always false. (Irreflexivity)

    • If areInIncreasingOrder(a, b) and areInIncreasingOrder(b, c) are both true, then areInIncreasingOrder(a, c) is also true. (Transitive comparability)

    • Two elements are incomparable if neither is ordered before the other according to the predicate. If a and b are incomparable, and b and c are incomparable, then a and c are also incomparable. (Transitive incomparability)

    The sorting algorithm is not guaranteed to be stable. A stable sort preserves the relative order of elements for which areInIncreasingOrder does not establish an order.