如何从协议实现中确定通用类型

Question

我有一个协议，其功能可以返回String或[String: String]。这是我的声明：

protocol Test { 
    associatedtype T: Hashable 
    func returnSomething() -> T 
} 

然后我想为returnSomething的默认实现，所以我做了一个协议扩展：

extension Test { 
    func returnSomething() -> T { 
     let valueToReturn = readValueFromPLISTthatCanReturnAStringOrDictionary() as T 
     return valueToReturn 
    } 
} 

所以最后我有2个clases，TestString和TestDictionary这两个工具Test协议我想指出T参数，我想使用默认实现。我如何做到这一点？

class TestString: Test {} 

class TestDictionary: Test { } 

class TestString: Test where Test.T = String or similar? 

Answer 1

我有一个协议有一个函数，可以返回一个字符串或[String：String]。这是我的声明：

没问题。我们写下来。

enum StringOrDictionary { 
    case string(String) 
    case dictionary([String: String]) 
} 

protocol Test { 
    func returnSomething() -> StringOrDictionary 
} 

然后我想为returnSomething的默认实现，所以我做了一个协议扩展：

听起来不错。我假设readValueFromPLISTthatCanReturnAStringOrDictionary()实际上返回Any，因为这是propertyList(from:)返回的内容。

extension Test { 
    func returnSomething() -> StringOrDictionary { 
     let value = readValueFromPLISTthatCanReturnAStringOrDictionary() 

     switch value { 
     case let string as String: return .string(string) 
     case let dictionary as [String: String]: return .dictionary(dictionary) 
     default: fatalError() // Or perhaps you'd like to do something else 
     } 
    } 
} 

这很可能是不错的命名类型的东西比StringOrDictionary比更有意义，但另一方面，它应该是相当简单的。只需制作一种表达你所说的话的类型即可。你想要一个类型意味着“或”，这是一个枚举。 （如果你想有一个类型的，意思是“AND”，这是一个结构BTW）

---

关于你的答案，这是不合法的：

class RandomClass: Test where Test.T == String { 
    func getValue() { 
     let bah = doSomething() // I don't need here to specify bah's type. 
    } 
} 

的方式来定义你的T是落实所需的方法。

class RandomClass: Test { 
    func returnSomething() -> String { 
     return "" 
    } 
} 

如果您想分享一些通用代码，那么您可以将它附加为扩展名而不是默认实现。你可以写一个returnString()方法并从RandomClass.returnSomething（）中调用它。这在某些情况下非常有用，但我绝对不会在这种情况下使用它。你不是指“返回任何可能的类型（T）”。你的意思是“返回两种可能类型之一”，这是一个枚举，而不是泛型。

更新：显然他们已经添加了一个他们已经提到的新功能，但我认为还没有。现在，您可以实现RandomClass这样：

class RandomClass: Test { 
    typealias T = String 
} 

（这是一个非常不错的新功能，即使它不是对于这个问题一个很好的答案。）

Answer 2

你需要，当你扩展类，像这样指定typealias：

protocol Test { 
    associatedtype T: Hashable 
    func returnSomething() -> T 
} 

extension String: Test { 
    typealias T = Int 
} 

func def() -> Int { 
    return 6 
} 

extension Test { 
    func returnSomething() -> T { 
     return def() as! Self.T 
    } 
} 

"".returnSomething() 

但是，我无法找到一个方法来做到这一点没有强制铸造。

Answer 3

这里是你的眼前问题的解决方案：

创建2个亚型的协议，各自有不同的定义相关的类型，不同的默认实现。您可以通过在两个子类型之间进行选择来选择要使用哪个默认实现。

这里的下一个问题是[String: String]不是Hashable。这是由于缺乏对条件一致性的支持（例如，如果密钥和值均为Hashable，表示Dictionary为Hashable）是Swift最大的缺陷之一IMO的能力。你可能会想使用类型擦除包装AnyHashable。

protocol ResultProvider { 
    associatedtype Result: Hashable 
    func getResult() -> Result 
} 

protocol StringResultProvider: ResultProvider { 
    typealias Result = String 
} 

extension StringResultProvider { 
    func getResult() -> String { 
     return "A string result" 
    } 
} 

protocol IntResultProvider: ResultProvider { 
    typealias Result = Int 
} 

extension IntResultProvider { 
    func getResult() -> Int { 
     return 123 
    } 
} 

class TestIntResult: IntResultProvider {} 
class TestString: StringResultProvider {} 

print(TestString().getResult()) 
print(TestIntResult().getResult()) 


// protocol DictionaryResultProvider: ResultProvider { 
//  typealias Result = [String: String] 
// } 

// extension DictionaryResultProvider { 
//  func getResult() -> [String: String] { 
//   return ["A dictionary": "result"] 
//  } 
// } 

// class TestDictionaryProvider: DictionaryResultProvider {} 

Answer 4

唯一的工作解决方案是在函数中做泛型并在调用函数时指定变量类型。我在想，如果当我实现类的协议，类似于这样我可以指定T类：

class RandomClass: Test where Test.T == String { 
    func getValue() { 
     let bah = doSomething() // I don't need here to specify bah's type. 
    } 
} 

但前面的例子就是不工作，所以另一种可能是这样的：

protocol Test { 
    func doSomething<T>() -> T 
} 

extension Test { 
    func doSomething<T>(key: String) -> T { 
     return returnDictOrStringFromPLIST(key: key) as! T 
    } 
} 

class TestString: Test { 
    func getValue() { 
     let bah: String = doSomething() 

    } 
} 

class TestDict: Test { 
    func getValue() { 
     let bah: [String: String] = doSomething() 

    } 
}