Swift通用完成处理程序

Question

我想弄清楚如何创建通用完成处理程序。下面是一个例子，举例说明一个示例“内部”通用完成处理程序和相同的通用完成处理程序，因为我希望能够创建它，如果我可以用“外部”形式来完成。问题是我不知道如何在完成处理程序中编写等效的internalCompletion<T: MyEnum>...。我写过externalCompletion函数，我想它可能看起来像：沿着func externalCompletion(_ completer<T: MyEnum>: ((T) -> Void) where T: Hashable))的行，但这显然是不正确的。我正在尝试做什么？我的直觉是，swift不会让完成处理程序保持通用，总是需要在功能级别进行类型转换，这会破坏每个示例的目的（即func externalCompletetion<T: MyEnum>(_ completer: ((T) -> Void)) where T: Hashable，这是我必须在EnumA， EnumB和EnumC，不能够在所有三个运行完成者。）

typealias MyEnumKeyedData<T: MyEnum> = [T: String] where T: Hashable 

// MARK : - MyEnum Protocol 

protocol MyEnum { 
    static func all<T: MyEnum>(_:T.Type) -> [T] where T: Hashable 
    static var all: [MyEnum] { get } 
} 
extension MyEnum { 
    static func all<T: MyEnum>(_:T.Type) -> [T] where T: Hashable { return Self.all as! [T] } 
} 

// MARK : - My enums 

enum EnumA: MyEnum { 
    case first 
    static var all: [MyEnum] { return [EnumA.first]} 
} 
enum EnumB: MyEnum { 
    case first 
    static var all: [MyEnum] { return [EnumB.first]} 
} 
enum EnumC: MyEnum { 
    case first 
    static var all: [MyEnum] { return [EnumC.first]} 
} 

// MARK : - MyEnum Data Iterator 

class MyDataEnumIterator { 
    var dataA: MyEnumKeyedData<EnumA> = [:] 
    var dataB: MyEnumKeyedData<EnumB> = [:] 
    var dataC: MyEnumKeyedData<EnumC> = [:] 

    func updateData<T: MyEnum>(_ key: T, _ value: String) where T: Hashable { 
    switch T.self { 
    case is EnumA.Type: dataA[key as! EnumA] = value 
    case is EnumB.Type: dataB[key as! EnumB] = value 
    case is EnumC.Type: dataC[key as! EnumC] = value 
    default: fatalError("Enum does not exist") 
    } 
    } 

    // Internal (This works) 

    func internalEnumIterator() { 
    for key in EnumA.all(EnumA.self) { internalCompletion(key) } 
    for key in EnumB.all(EnumB.self) { internalCompletion(key) } 
    for key in EnumC.all(EnumC.self) { internalCompletion(key) } 
    } 

    func internalCompletion<T: MyEnum>(_ key: T) where T: Hashable { 
    let value = "\(key)" 
    updateData(key, value) 
    } 

    // External (This obviously doesn't, just sketching the idea) 

    func externalEnumIterator(_ completer<T: MyEnum>: ((T) -> Void) where T: Hashable) { 
    for key in EnumA.all(EnumA.self) { completer(key) } 
    for key in EnumB.all(EnumB.self) { completer(key) } 
    for key in EnumC.all(EnumC.self) { completer(key) } 
    } 
} 

// MARK : - Test cases (internal works, external does not, just sketching example) 

let iterator = MyDataEnumIterator() 
iterator.externalEnumIterator({ <T: MyEnum> (T) where T: Hashable in 
    let value = "\(key)" 
    iterator.updateData(key, value) 
}) 
iterator.internalEnumIterator() 

Answer 1

下面是代码的必要的最小变化的工作版本，以获得它去

typealias MyEnumKeyedData<T: MyEnum> = [T: String] where T: Hashable 

// MARK : - MyEnum Protocol 

protocol MyEnum { 
    static func all<T: MyEnum>(_:T.Type) -> [T] where T: Hashable 
    static var all: [MyEnum] { get } 
} 
extension MyEnum { 
    static func all<T: MyEnum>(_:T.Type) -> [T] where T: Hashable { return Self.all as! [T] } 
} 

// MARK : - My enums 

enum EnumA: MyEnum { 
    case first 
    static var all: [MyEnum] { return [EnumA.first]} 
} 
enum EnumB: MyEnum { 
    case first 
    static var all: [MyEnum] { return [EnumB.first]} 
} 
enum EnumC: MyEnum { 
    case first 
    static var all: [MyEnum] { return [EnumC.first]} 
} 

// MARK : - MyEnum Data Iterator 

class MyDataEnumIterator { 
    var dataA: MyEnumKeyedData<EnumA> = [:] 
    var dataB: MyEnumKeyedData<EnumB> = [:] 
    var dataC: MyEnumKeyedData<EnumC> = [:] 

    func updateData(_ key: MyEnum, _ value: String) { 
     switch key { 
     case let key as EnumA: dataA[key] = value 
     case let key as EnumB: dataB[key] = value 
     case let key as EnumC: dataC[key] = value 
     default: fatalError("Enum does not exist") 
     } 
    } 

    // Internal (This works) 

    func internalEnumIterator() { 
     for key in EnumA.all(EnumA.self) { internalCompletion(key) } 
     for key in EnumB.all(EnumB.self) { internalCompletion(key) } 
     for key in EnumC.all(EnumC.self) { internalCompletion(key) } 
    } 

    func internalCompletion<T: MyEnum>(_ key: T) where T: Hashable { 
     let value = "\(key)" 
     updateData(key, value) 
    } 

    func EnumIterator(_ compeltitionHandler: (MyEnum) -> Void) { 
     for key in EnumA.all(EnumA.self) { compeltitionHandler(key as MyEnum) } 
     for key in EnumB.all(EnumB.self) { compeltitionHandler(key as MyEnum) } 
     for key in EnumC.all(EnumC.self) { compeltitionHandler(key as MyEnum) } 
    } 
} 


let iterator = MyDataEnumIterator() 

iterator.EnumIterator{ key in 
    let value = "\(key)" 
    iterator.updateData(key, value) 
} 
iterator.internalEnumIterator() 

这里一个合理的代码版本，删除所有的废话，并添加下标语法：

// MARK : - MyEnum Protocol 

protocol MyEnum { 
    static func all() -> [MyEnum] 
} 

// MARK : - My enums 

enum EnumA: MyEnum { 
    case first 
    static func all() -> [MyEnum] { return [EnumA.first] } 
} 
enum EnumB: MyEnum { 
    case first 
    static func all() -> [MyEnum] { return [EnumB.first] } 
} 
enum EnumC: MyEnum { 
    case first 
    static func all() -> [MyEnum] { return [EnumC.first] } 
} 

// MARK : - MyEnum Data Iterator 

class MyDataEnumIterator { 
    var dataA = [EnumA: String]() 
    var dataB = [EnumB: String]() 
    var dataC = [EnumC: String]() 


    subscript(key: MyEnum) -> String? { 
     get { 
      switch key { 
      case let key as EnumA: return dataA[key] 
      case let key as EnumB: return dataB[key] 
      case let key as EnumC: return dataC[key] 
      default: fatalError("Enum does not exist") 
      } 
     } 
     set { 
      switch key { 
      case let key as EnumA: dataA[key] = newValue 
      case let key as EnumB: dataB[key] = newValue 
      case let key as EnumC: dataC[key] = newValue 
      default: fatalError("Enum does not exist") 
      } 
     } 
    } 

    func EnumIterator(_ body: (MyEnum) -> Void) { 
     EnumA.all().forEach(body); 
     EnumB.all().forEach(body); 
     EnumC.all().forEach(body); 
    } 
} 


let iterator = MyDataEnumIterator() 
iterator.EnumIterator{ 
    iterator[$0] = "\($0)" 
}