如何使用 Swift KeyPath 的异构数组

Question

似乎应该可以使用一个KeyPath数组作为排序键，以使用任意数量的排序键对 Swift 结构数组进行排序。 从概念上讲，这很简单。将键路径数组定义为泛型对象，其中唯一的限制是键路径中的属性Comparable。

只要所有键路径都指向相同类型的属性，一切就好了。但是，一旦您尝试使用指向数组中不同类型的元素的 KeyPath，它就会停止工作。

请参阅下面的代码。我创建了一个具有 2 个 Int 属性和一个双精度属性的简单结构。我创建了一个实现函数sortedByKeypaths(_:)的 Array 扩展 该函数指定可比较的泛型类型 PROPERTY。它将一个 kepath 数组带到指定 PROPERTY 类型的属性的某个对象 Element。(可比属性。

只要您使用 KeyPath 数组调用该函数，这些属性都是相同类型的属性，它就可以完美地工作。

但是，如果您尝试将键路径数组传递给不同类型的属性，则会引发错误 "无法将类型"[部分键路径]"的值转换为预期的参数类型"[键路径]">

由于数组包含异构键路径，因此由于类型擦除，数组将转换为类型"[PartialKeyPath]"，并且不能使用 PartialKeyPath 从数组中获取元素。

这个问题有解决方案吗？无法使用 KeyPath 的异构数组似乎严重限制了 Swift KeyPath 的实用性

。

import UIKit
struct Stuff {
let value: Int
let value2: Int
let doubleValue: Double
}
extension Array {
func sortedByKeypaths<PROPERTY: Comparable>(_ keypaths: [KeyPath<Element, PROPERTY>]) -> [Element] {
return self.sorted { lhs, rhs in
var keypaths = keypaths
while !keypaths.isEmpty {
let keypath = keypaths.removeFirst()
if lhs[keyPath: keypath] != rhs[keyPath: keypath] {
return lhs[keyPath: keypath] < rhs[keyPath: keypath]
}
}
return true
}
}
}
var stuff = [Stuff]()
for _ in 1...20 {
stuff.append(Stuff(value: Int(arc4random_uniform(5)),
value2: Int(arc4random_uniform(5)),
doubleValue: Double(arc4random_uniform(10))))
}
let  sortedStuff = stuff.sortedByKeypaths([Stuff.value, Stuff.value2]) //This works
sortedStuff.forEach { print($0) }
let  moreSortedStuff = stuff.sortedByKeypaths([Stuff.value, Stuff.doubleValue]) //This throws a compiler error
moreSortedStuff.forEach { print($0) }

Answer 1

使用部分键路径数组的问题在于，您无法保证属性类型Comparable。一种可能的解决方案是使用类型擦除包装器来擦除键路径的值类型，同时确保其Comparable：

struct PartialComparableKeyPath<Root> {
private let _isEqual: (Root, Root) -> Bool
private let _isLessThan: (Root, Root) -> Bool
init<Value : Comparable>(_ keyPath: KeyPath<Root, Value>) {
self._isEqual = { $0[keyPath: keyPath] == $1[keyPath: keyPath] }
self._isLessThan = { $0[keyPath: keyPath] < $1[keyPath: keyPath] }
}
func isEqual(_ lhs: Root, _ rhs: Root) -> Bool {
return _isEqual(lhs, rhs)
}
func isLessThan(_ lhs: Root, _ rhs: Root) -> Bool {
return _isLessThan(lhs, rhs)
}
}

然后，您可以将排序函数实现为：

extension Sequence {
func sorted(by keyPaths: PartialComparableKeyPath<Element>...) -> [Element] {
return sorted { lhs, rhs in
for keyPath in keyPaths {
if !keyPath.isEqual(lhs, rhs) {
return keyPath.isLessThan(lhs, rhs)
}
}
return false
}
}
}

然后像这样使用：

struct Stuff {
let value: Int
let value2: Int
let doubleValue: Double
}
var stuff = [Stuff]()
for _ in 1 ... 20 {
stuff.append(Stuff(value: Int(arc4random_uniform(5)),
value2: Int(arc4random_uniform(5)),
doubleValue: Double(arc4random_uniform(10))))
}

let sortedStuff = stuff.sorted(by: PartialComparableKeyPath(.value),
PartialComparableKeyPath(.value2))
sortedStuff.forEach { print($0) }
let moreSortedStuff = stuff.sorted(by: PartialComparableKeyPath(.value),
PartialComparableKeyPath(.doubleValue))
moreSortedStuff.forEach { print($0) }

但不幸的是，这需要将每个单独的键路径包装在一个PartialComparableKeyPath值中，以便捕获和擦除键路径的值类型，这不是特别漂亮。

实际上，我们在这里需要的功能是可变参数泛型，它允许您在键路径的值类型的可变数量的泛型占位符上定义函数，每个占位符都限制为Comparable。

在此之前，另一种选择是为不同数量的键路径编写给定数量的重载进行比较：

extension Sequence {
func sorted<A : Comparable>(by keyPathA: KeyPath<Element, A>) -> [Element] {
return sorted { lhs, rhs in
lhs[keyPath: keyPathA] < rhs[keyPath: keyPathA]
}
}
func sorted<A : Comparable, B : Comparable>
(by keyPathA: KeyPath<Element, A>, _ keyPathB: KeyPath<Element, B>) -> [Element] {
return sorted { lhs, rhs in
(lhs[keyPath: keyPathA], lhs[keyPath: keyPathB]) <
(rhs[keyPath: keyPathA], rhs[keyPath: keyPathB])
}
}
func sorted<A : Comparable, B : Comparable, C : Comparable>
(by keyPathA: KeyPath<Element, A>, _ keyPathB: KeyPath<Element, B>, _ keyPathC: KeyPath<Element, C>) -> [Element] {
return sorted { lhs, rhs in
(lhs[keyPath: keyPathA], lhs[keyPath: keyPathB], lhs[keyPath: keyPathC]) <
(rhs[keyPath: keyPathA], rhs[keyPath: keyPathB], rhs[keyPath: keyPathC])
}
}
func sorted<A : Comparable, B : Comparable, C : Comparable, D : Comparable>
(by keyPathA: KeyPath<Element, A>, _ keyPathB: KeyPath<Element, B>, _ keyPathC: KeyPath<Element, C>, _ keyPathD: KeyPath<Element, D>) -> [Element] {
return sorted { lhs, rhs in
(lhs[keyPath: keyPathA], lhs[keyPath: keyPathB], lhs[keyPath: keyPathC], lhs[keyPath: keyPathD]) <
(rhs[keyPath: keyPathA], rhs[keyPath: keyPathB], rhs[keyPath: keyPathC], rhs[keyPath: keyPathD])
}
}
func sorted<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>
(by keyPathA: KeyPath<Element, A>, _ keyPathB: KeyPath<Element, B>, _ keyPathC: KeyPath<Element, C>, _ keyPathD: KeyPath<Element, D>, _ keyPathE: KeyPath<Element, E>) -> [Element] {
return sorted { lhs, rhs in
(lhs[keyPath: keyPathA], lhs[keyPath: keyPathB], lhs[keyPath: keyPathC], lhs[keyPath: keyPathD], lhs[keyPath: keyPathE]) <
(rhs[keyPath: keyPathA], rhs[keyPath: keyPathB], rhs[keyPath: keyPathC], rhs[keyPath: keyPathD], rhs[keyPath: keyPathE])
}
}
func sorted<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>
(by keyPathA: KeyPath<Element, A>, _ keyPathB: KeyPath<Element, B>, _ keyPathC: KeyPath<Element, C>, _ keyPathD: KeyPath<Element, D>, _ keyPathE: KeyPath<Element, E>, _ keyPathF: KeyPath<Element, F>) -> [Element] {
return sorted { lhs, rhs in
(lhs[keyPath: keyPathA], lhs[keyPath: keyPathB], lhs[keyPath: keyPathC], lhs[keyPath: keyPathD], lhs[keyPath: keyPathE], lhs[keyPath: keyPathF]) <
(rhs[keyPath: keyPathA], rhs[keyPath: keyPathB], rhs[keyPath: keyPathC], rhs[keyPath: keyPathD], rhs[keyPath: keyPathE], rhs[keyPath: keyPathF])
}
}
}

我已经定义了多达 6 个键路径，这对于大多数排序情况来说应该足够了。 我们在这里利用了<的词典元组比较重载，如此处所示。

虽然实现并不漂亮，但调用站点现在看起来好多了，因为它可以让你说：

let sortedStuff = stuff.sorted(by: .value, .value2)
sortedStuff.forEach { print($0) }
let moreSortedStuff = stuff.sorted(by: .value, .doubleValue)
moreSortedStuff.forEach { print($0) }