键路径值类型“Int”无法转换为上下文类型“String”

我试图将包含 KeyPath 和排序顺序类型的多个元组传递给应该进行排序的方法。

我有这个方法：

extension Array {
    mutating func sort<T: Comparable>(by criteria: (path: KeyPath<Element, T>, order:OrderType)...) {
        
        criteria.forEach { path, order in
            //...
            sort { first, second in
            order.makeComparator()(
                first[keyPath: path],
                second[keyPath: path]
            )
        }
        }
    }
}

我这样使用它：

var posts = BlogPost.examples
        
posts.sort(by:(path:\.pageViews, order: .asc), (path:\.sessionDuration, order: .desc))

现在，导致两者pageViews and sessionDuration属性是integers，这会起作用。

但是如果我想传递两个不同类型的属性（比如String and Int），我收到此错误：

Key path value type 'Int' cannot be converted to contextual type 'String'

这是其余的代码，但我猜不是那么相关：

enum OrderType: String {
    case asc
    case desc
}

extension OrderType {
    func makeComparator<T: Comparable>() -> (T, T) -> Bool {
        switch self {
        case .asc:
            return (<)
        case .desc:
            return (>)
        }
    }
}

我应该如何定义排序方法以便它接受异质的关键路径？

在 Swift 5.9 中，您可以使用参数包编写这样的方法。这里我使用内置的排序来实现KeyPathComparator:

extension Array {
    mutating func sort<each T: Comparable>(by keyPaths: repeat (KeyPath<Element, each T>, SortOrder)) {
        var comparators: [KeyPathComparator<Element>] = []
        func addComparator<Key: Comparable>(_ keyPathOrder: (KeyPath<Element, Key>, SortOrder)) {
            comparators.append(KeyPathComparator(keyPathOrder.0, order: keyPathOrder.1))
        }
        // here I am technically creating a tuple, with its elements all being addComparator calls
        // this could be written more readably when we can iterate over a parameter pack with a for loop
        (repeat addComparator(each keyPaths))
        sort(using: comparators)
    }
}

用法示例：

// order by length of string ascendingly, then by the string itself descendingly
someStrings.sort(by: (\.count, .forward), (\.self, .reverse))

在 Swift 5.9 之前，您需要编写AnyComparable类型橡皮擦。这个是根据这篇文章改编的here https://stackoverflow.com/questions/68878549/class-anycomparable-inherits-from-class-anyequatable/68878884#68878884.

struct AnyComparable: Equatable, Comparable {
    private let lessThan: (Any) -> Bool
    private let value: Any
    private let equals: (Any) -> Bool

    public static func == (lhs: AnyComparable, rhs: AnyComparable) -> Bool {
        lhs.equals(rhs.value) || rhs.equals(lhs.value)
    }
    
    public init<C: Comparable>(_ value: C) {
        self.value = value
        self.equals = { $0 as? C == value }
        self.lessThan = { ($0 as? C).map { value < $0 } ?? false }
    }

    public static func < (lhs: AnyComparable, rhs: AnyComparable) -> Bool {
        lhs.lessThan(rhs.value) || (rhs != lhs && !rhs.lessThan(lhs.value))
    }
}

这样，你就可以写你的sort方法签名为：

mutating func sort(by criteria: (path: KeyPath<Element, AnyComparable>, order:OrderType)...) {
    
    
}

为了让我们更容易用类型传递关键路径AnyComparable中，我们可以进行扩展：

extension Comparable {
    // this name might be too long, but I'm sure you can come up with a better name
    var anyComparable: AnyComparable {
        .init(self)
    }
}

现在我们可以这样做：

someArray.sort(by: (\.key1.anyComparable, .asc), (\.key2.anyComparable, .asc))