Возможно ли иметь функцию, которая принимает либо Set, либо Array и вызывает сортировку (по :)?

Question

Я хотел бы написать метод, который принимает Set или Array,

как Collection -конформирующий параметр или что-то в этом роде

Проблемазаключается в том, что sorted(by:) существует на уровне Set и Array,

https://developer.apple.com/documentation/swift/set/2296160-sorted

https://developer.apple.com/documentation/swift/array/2296815-sorted

и не объявлено влюбой из протоколов, которым они оба соответствуют.

Вот мой метод сортировки:

class func sortArray(_ array:[Bom]) -> [Bom] {  

или

class func sortArray(_ array:Set<Bom>) -> [Bom] {
    return array.sorted {
        if $0.prop1 == $1.prop1 {
            if $0.prop2 == $1.prop2 {
                if $0.prop3 == $1.prop3 {
                    return $0.prop4 ?? "" < $1.prop4 ?? ""
                } else {
                    return $0.prop3 ?? "" < $1.prop3 ?? ""
                }
            } else {
                return $0.prop2 ?? "" < $1.prop2 ?? ""
            }
        } else {
            return $0.prop1 < $1.prop1
        }
    }
}

Я могускопируйте и вставьте этот метод и измените тип параметра с [BOM] на Set<Bom> все работает, но теперь у меня есть буквальная функция вставки с копированием, единственное отличие состоит в типе параметра ...

amЯ упустил что-то простое здесь?

Answer 1

sorted(by:) существует во всех последовательностях.Ваш конкретный случай требует Bom, поэтому вам нужно ограничиться этим:

class func sortValues<S: Sequence>(_ values: S) -> [S.Element] where S.Element == Bom {
    // .. the rest of your method
}

Вы также можете ограничиться Collection.

Вы также можете сделать это расширением на Sequence или Collection из Bom:

extension Sequence where Element == Bom {
    func sorted() -> [Bom] {
        return self.sorted {
            // .. the rest of your method
        }
    }
}

Если так всегда нужно упорядочивать Boms, вы можете также рассмотреть возможность сделать их Comparable, и тогда все обычные методы сортировки будут работать на всех последовательностях:

extension Bom: Comparable {
    static func < (lhs: Bom, rhs: Bom) -> Bool {
        if lhs.prop1 == rhs.prop1 {
            if lhs.prop2 == rhs.prop2 {
                if lhs.prop3 == rhs.prop3 {
                    return lhs.prop4 ?? "" < rhs.prop4 ?? ""
                } else {
                    return lhs.prop3 ?? "" < rhs.prop3 ?? ""
                }
            } else {
                return lhs.prop2 ?? "" < rhs.prop2 ?? ""
            }
        } else {
            return lhs.prop1 < rhs.prop1
        }
    }
}