Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.

SDK

- Xcode 8.0+

Framework

- Swift Standard Library

## Declaration

## Parameters

`areInIncreasingOrder`

A predicate that returns

`true`

if its first argument should be ordered before its second argument; otherwise,`false`

.

## Return Value

A sorted array of the sequence’s elements.

## Discussion

When you want to sort a sequence of elements that don’t conform to the `Comparable`

protocol, pass a predicate to this method that returns `true`

when the first element should be ordered before the second. The elements of the resulting array are ordered according to the given predicate.

In the following example, the predicate provides an ordering for an array of a custom `HTTPResponse`

type. The predicate orders errors before successes and sorts the error responses by their error code.

You also use this method to sort elements that conform to the `Comparable`

protocol in descending order. To sort your sequence in descending order, pass the greater-than operator (`>`

) as the `are`

parameter.

Calling the related `sorted()`

method is equivalent to calling this method and passing the less-than operator (`<`

) as the predicate.

The predicate must be a *strict weak ordering* over the elements. That is, for any elements `a`

, `b`

, and `c`

, the following conditions must hold:

`are`

is alwaysIn Increasing Order(a, a) `false`

. (Irreflexivity)If

`are`

andIn Increasing Order(a, b) `are`

are bothIn Increasing Order(b, c) `true`

, then`are`

is alsoIn Increasing Order(a, c) `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 `are`

does not establish an order.

Complexity: O(*n* log *n*), where *n* is the length of the sequence.