# seq.sorted()

```swift
// seq.sorted()
func sorted() -> [Self.Element]
  where Self.Element: Comparable
```

{% tabs %}
{% tab title="sorted()" %}

```swift
// ⭐️ sort `Comparable` elements in ascending order (default).
let numbers: [Int] = [3, 2, 4, 1]
let sortedNumbers = numbers.sorted()

// ⭐️ in descending order.
numbers.sorted(by: >)

// ⭐️ make custom type conform to `Comparable`
extension TodoItem: Comparable {
    static func < (a: TodoItem, b: TodoItem) -> Bool {
        a.date < b.date
    }
}

todolist.sorted()
```

{% endtab %}

{% tab title="TodoItem" %}

```swift
import Foundation  // Date

// todo item
struct TodoItem {
    let date: Date
    let item: String
}

// todo item samples
let todos = ["eat", "sleep", "play", "relax"]
let now = Date()
let nextyear = now.yearAfter

extension TodoItem {
    static let samples = (1...5).map{ _ in 
        TodoItem(
            date: .random(in: now...nextyear), 
            item: todos.randomElement()!
        )
    }
}

let todolist = TodoItem.samples
```

{% endtab %}

{% tab title="📘 手冊" %}

* Swift ⟩ Collections ⟩ [Sequence](https://developer.apple.com/documentation/swift/sequence)
  * [.sorted()](https://developer.apple.com/documentation/swift/sequence/1641066-sorted) - sorted in <mark style="color:red;">**ascending**</mark> order, to sort in <mark style="color:red;">**descending**</mark> order, use: <mark style="color:red;">**.sorted(by: >)**</mark>.
  * Array ⟩&#x20;
    * [sort()](https://developer.apple.com/documentation/swift/array/1688499-sort) - sort in place.
    * [sort(by:)](https://developer.apple.com/documentation/swift/array/2296801-sort) - sort in place.
      {% endtab %}

{% tab title="📗 參考" %}

* Sundell ⟩ [Sorting Swift collections](https://www.swiftbysundell.com/articles/sorting-swift-collections/) ⭐️
  {% endtab %}

{% tab title="👥 相關" %}

* [seq.sorted-by](https://lochiwei.gitbook.io/ios/swift/collections/sequence/seq.sorted-by "mention")
  {% endtab %}
  {% endtabs %}

## Examples

{% tabs %}
{% tab title="sorted()" %}

```swift
// custom type
enum Response {
    case ok
    case error(Int)
}

// ⭐️ make custom type conform to `Comparable`
extension Response: Comparable {
    // Q: a is before b ?
    static func < (a: Response, b: Response) -> Bool {
        switch (a, b) {
            
            // errors ordered by error codes (increasing)
            case let (.error(m), .error(n)): return m < n

            // successes are equivalent, none is before any other
            case (.ok, .ok): return false

            // error is before success
            case (.error, .ok): return true
            case (.ok, .error): return false
        }
    }
}

let responses: [Response] = [
    .error(500), .ok, .ok, .error(404), .error(403)
]

responses.sorted()
// [.error(403), .error(404), .error(500), .ok, .ok]
```

{% endtab %}

{% tab title="sort(by:)" %}

```swift
enum Response {
    case ok
    case error(Int)
}

var responses: [Response] = [
    .error(500), .ok, .ok, .error(404), .error(403)
]

// ⭐️ sort in place
responses.sort {
    // Q: $0 is before $1 ?
    switch ($0, $1) {
        
        // error ordered by error code (increasing)
        case let (.error(m), .error(n)): return m < n

        // successes are equivalent, none is before any other
        case (.ok, .ok): return false

        // error is before success
        case (.error, .ok): return true
        case (.ok, .error): return false
    }
}
```

{% endtab %}
{% endtabs %}