如何解决在 Swift 中，如何通过为不同的键路径注册处理器来实现处理类型的通用系统？
我想实现一个系统，允许我通过为不同的键路径注册处理器来通用地处理类型。
系统的一个特征应该是 composition，所以每个处理器都应该扩展一个通用的通用协议 Processor。
用法示例：
struct Language {
var name = "Swift"
var version = 5.3
}
var processor = TypeProcessor<Language>()
processor.add(procesor: VersionProcessor(),keypath: \.version)
processor.add(procesor: NameProcessor(),keypath: \.name)
var input = Language()
processor.process(value: input)
// Languge version: 5.3
// Languge name: Swift
解决方法
您可以使用“处理器”的继承，而不是尝试擦除属性类型，其中子类在根对象和属性类型上是通用的，并且具有属性键路径。
protocol Processor {
associatedtype T
func process(value: T)
}
class AnyProcessor<Value>: Processor {
func process(value: Value) {
}
}
final class KeyPathProcessor<Root,P: Processor>: AnyProcessor<Root> {
typealias Value = P.T
let keyPath: KeyPath<Root,Value>
let processor: P
init(keyPath: KeyPath<Root,Value>,processor: P) {
self.keyPath = keyPath
self.processor = processor
}
override func process(value: Root) {
processor.process(value: value[keyPath: keyPath])
}
}
struct ObjectProcessor<T>: Processor {
var processors = [AnyKeyPath: AnyProcessor<T>]()
mutating func add<P: Processor,V>(processor: P,keypath: KeyPath<T,V>) where P.T == V {
self.processors[keypath] = KeyPathProcessor(keyPath: keypath,processor: processor)
}
func process(value: T) {
for (_,processor) in processors {
processor.process(value: value)
}
}
}
我创建了一个 playground，展示了如何通过函数组合解决这个问题，然后使用我们在那里学到的知识重新创建您的示例。
函数组合允许您通过将现有函数链接在一起来创建新函数，只要类型匹配即可。
precedencegroup CompositionPrecedence {
associativity: left
}
infix operator >>>: CompositionPrecedence
func >>> <T,U,V>(lhs: @escaping (T) -> U,rhs: @escaping (U) -> V) -> (T) -> V {
return { rhs(lhs($0)) }
}
Processor 可以转换为一个函数，它接受一个对象 O，以某种方式对其进行转换，然后返回一个新对象。创建函数可以这样完成：
func process<O,K>(keyPath: WritableKeyPath<O,K>,_ f: @escaping (K) -> K) -> (O) -> O {
return { object in
var writable = object
writable[keyPath: keyPath] = f(object[keyPath: keyPath])
return writable
}
}
let reverseName = process(keyPath: \Person.name,reverse)
let halfAge = process(keyPath: \Person.age,half)
现在我们可以组合这两个函数了。结果函数仍然保留签名`(Person) -> Person)。我们可以组合任意数量的函数，创建一个处理管道。
let benjaminButton = reverseName >>> halfAge
let youngBradPitt = benjaminButton(bradPitt)
继续重新创建您的示例。正如此 answer 所提到的，该类型在根对象上是通用的。这就像在函数组合示例中一样，它允许我们将所有处理器组合在一个数组中。
protocol Processor {
associatedtype T
func process(object: T) -> T
}
擦除对象时，保留对原始对象的引用很重要，以便我们可以使用它来实现所需的功能。在本例中，我们保留对其 process(:) 方法的引用。
extension Processor {
func erased()-> AnyProcessor<T> {
AnyProcessor(base: self)
}
}
struct AnyProcessor<T>: Processor {
private var _process: (T) -> T
init<Base: Processor>(base: Base) where Base.T == T {
_process = base.process
}
func process(object: T) -> T {
_process(object)
}
}
这是实现 Processor 协议的两种类型。请注意，第一个有两种占位符类型。第二个占位符将被删除。
struct AgeMultiplier<T,K: Numeric>: Processor {
let multiplier: K
let keyPath: WritableKeyPath<T,K>
private func f(_ value: K) -> K {
value * multiplier
}
func process(object: T) -> T {
var writable = object
writable[keyPath: keyPath] = f(object[keyPath: keyPath])
return writable
}
}
struct NameUppercaser<T>: Processor {
let keyPath: WritableKeyPath<T,String>
private func f(_ value: String) -> String {
value.uppercased()
}
func process(object: T) -> T {
var writable = object
writable[keyPath: keyPath] = f(object[keyPath: keyPath])
return writable
}
}
最后是使用对象组合的 ObjectProcessor。请注意，数组包含相同类型的对象。例如，此结构的实例将只能处理 Person。每个子处理器所做的事情都隐藏在实现中，并且它可能在不同类型的数据上运行这一事实不会影响 ObjectProcessor。
struct ObjectProcessor<T>: Processor {
private var processers = [AnyProcessor<T>]()
mutating func add(processor: AnyProcessor<T>) {
processers.append(processor)
}
func process(object: T) -> T {
var object = object
for processor in processers {
object = processor.process(object: object)
}
return object
}
}
它正在发挥作用。请注意，我为同一个密钥添加了两个处理器。
var holyGrail = ObjectProcessor<Person>()
holyGrail.add(processor: NameUppercaser(keyPath: \Person.name).erased())
holyGrail.add(processor: AgeMultiplier(multiplier: 2,keyPath: \Person.age).erased())
holyGrail.add(processor: AgeMultiplier(multiplier: 3,keyPath: \Person.age).erased())
let bradPitt = Person(name: "Brad Pitt",age: 57)
let immortalBradPitt = holyGrail.process(object: bradPitt)
感谢您的回答。我已经使用了您的输入并提出了以下解决方案：
protocol Processor {
associatedtype T
func process(value: T)
}
extension Processor {
func erase()-> AnyProcessor<T> {
return AnyProcessor<T>(self)
}
}
struct AnyProcessor<T>: Processor {
let process: (T) -> Void
init<P: Processor>(_ processor: P) where P.T == T {
self.process = processor.process
}
func process(value: T) {
self.process(value)
}
}
struct KeyPathProcessor<T,V>: Processor {
private var keyPath: KeyPath<T,V>
private var processor: AnyProcessor<V>
init<P: Processor>(_ processor: P,for keyPath: KeyPath<T,V>) where P.T == V {
self.processor = processor.erase()
self.keyPath = keyPath
}
func process (value: T) {
let input = value[keyPath: keyPath]
processor.process(value: input)
}
}
struct VersionProcessor: Processor {
func process(value: Double) {
print("Languge version: \(value)")
}
}
struct NameProcessor: Processor {
func process(value: String) {
print("Languge name: \(value)")
}
}
struct TypeProcessor<T>: Processor {
var processors = [AnyProcessor<T>]()
mutating func add<P: Processor,V>(procesor: P,V>) where P.T == V {
let p = KeyPathProcessor(procesor,for: keypath).erase()
self.processors.append(p)
}
func process(value: T) {
for processor in processors {
processor.process(value: value)
}
}
}
struct Language {
var name = "Swift"
var version = 5.3
}
var processor = TypeProcessor<Language>()
processor.add(procesor: VersionProcessor(),keypath: \.version)
processor.add(procesor: NameProcessor(),keypath: \.name)
var input = Language()
processor.process(value: input)
// Languge version: 5.3
// Languge name: Swift
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
