map(keyPath)，其中keyPath是一个变量

Question

let arr = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]
arr.map(.0) // [1, 2, 3, 4, 5]

效果很好。但以下代码无法编译：

let keyPath = (Int, Int).0
arr.map(keyPath)

无法转换'WritableKeyPath<类型的值；(Int，Int(，Int>'到预期的参数类型"((Int，Int((throws->T'
无法推断出泛型参数"T"。

Answer 1

Array.map期望一个具有签名(Element) throws -> T的闭包。

在Swift 5.2中，关键路径被允许作为函数/闭包传递(这是一个进化建议(，但只能作为文字(至少，根据该建议，它说"暂时"，所以也许这个限制会被取消(。

为了克服这个问题，您可以在Sequence上创建一个接受密钥路径的扩展：

extension Sequence {
func map<T>(_ keyPath: KeyPath<Element, T>) -> [T] {
return map { $0[keyPath: keyPath] }
}
}

^{(贷记至：https://www.swiftbysundell.com/articles/the-power-of-key-paths-in-swift/)}

然后你可以做你想做的事：

let keyPath = (Int, Int).0
arr.map(keyPath)

Answer 2

进化方案展示了如何使用运算符，但无论是否部分应用，您也可以使用相同的[]或()语法，因为下标和函数不需要参数。

let oneTo5 = 1...5
let keyPath = (Int, Int).0
XCTAssert(
zip(oneTo5, oneTo5).map(keyPath[]).elementsEqual(oneTo5)
)

let keyPath = Double.isZero
XCTAssertFalse(keyPath[1.0]())

public extension KeyPath {
/// Convert a `KeyPath` to a partially-applied get accessor.
subscript() -> (Root) -> Value {
{ $0[keyPath: self] }
}
/// Convert a `KeyPath` to a get accessor.
subscript(root: Root) -> () -> Value {
{ root[keyPath: self] }
}
}
public extension ReferenceWritableKeyPath {
/// Convert a `KeyPath` to a partially-applied get/set accessor pair.
subscript() -> (Root) -> Computed<Value> {
{ self[$0] }
}
/// Convert a `KeyPath` to a get/set accessor pair.
subscript(root: Root) -> Computed<Value> {
.init(
get: self[root],
set: { root[keyPath: self] = $0 }
)
}
}

/// A workaround for limitations of Swift's computed properties.
///
/// Limitations of Swift's computed property accessors:
/// 1. They are not mutable.
/// 2. They cannot be referenced as closures.
@propertyWrapper public struct Computed<Value> {
public typealias Get = () -> Value
public typealias Set = (Value) -> Void
public init(
get: @escaping Get,
set: @escaping Set
) {
self.get = get
self.set = set
}
public var get: Get
public var set: Set
public var wrappedValue: Value {
get { get() }
set { set(newValue) }
}
public var projectedValue: Self {
get { self }
set { self = newValue }
}
}
//MARK:- public
public extension Computed {
init(
wrappedValue: Value,
get: @escaping Get = {
fatalError("`get` must be assigned before accessing `wrappedValue`.")
},
set: @escaping Set
) {
self.init(get: get, set: set)
self.wrappedValue = wrappedValue
}
}