Generic Protocols

import Foundation

protocol Sortable: Comparable {
    var number: Int {get}
    
    static func < (lhs:Self, rhs: Self) -> Bool
    static func == (lhs:Self, rhs: Self) -> Bool
}

struct BasicSortable: Sortable {
    let number: Int
    
    static func < (lhs:BasicSortable, rhs: BasicSortable) -> Bool {
        return lhs.number < rhs.number
    }
    
    static func == (lhs:BasicSortable, rhs: BasicSortable) -> Bool {
        return lhs.number == rhs.number
    }
}

protocol Sorter {
    associatedtype Item: Sortable
    
    func sort(items: [Item]) -> [Item]
}

struct AscendingSorter<T:Sortable>: Sorter {
    typealias Item = T

    func sort(items: [T]) -> [T] {
        return items.sorted()
    }
}

struct DescendingSorter<T:Sortable>: Sorter {
    typealias Item = T
    
    func sort(items: [T]) -> [T] {
        return items.sorted{$0 > $1}
    }
}

struct DataHandler<T: Sortable> {
    let items: [T]
    let sortedItems: [T]
    
    init <S: Sorter>(unsortedItems: [T], sorter: S) where S.Item == T {
        items = unsortedItems
        sortedItems = sorter.sort(items: unsortedItems)
    }
}

let array = [
    BasicSortable(number: 1),
    BasicSortable(number: 8),
    BasicSortable(number: 13),
    BasicSortable(number: 3),
    BasicSortable(number: 4),
    BasicSortable(number: 14),
    BasicSortable(number: 5),
    BasicSortable(number: 12),
    BasicSortable(number: 3),
]

let handler = DataHandler(unsortedItems: array, sorter: DescendingSorter())

handler.sortedItems