Question

我试图通过以下方式扩展协议但是我收到错误：无法将typeable类型的返回表达式转换为typable。

我想说typalias MyType : inside MyType必须是符合inside的实体

struct typeable<T> {
    let value : String = "hello world"
}

protocol inside {
        func __myFunction() -> typeable<inside>
}  

protocol outside : inside {
    typealias MyType : inside

    func myFunction() -> typeable<MyType>
}

extension outside {
    final func __myFunction() -> typeable<inside> {
        return self.myFunction()
    }
}

struct thing : outside {
    typealias MyType = thing

    func myFunction() -> typeable<thing> {
        return typeable<thing>()
    }
}

Answer 1

您的inside协议：

protocol inside {
    func __myFunction() -> typeable<inside>
}

...需要一个返回类型为typeable<inside>的函数，该函数与typeable<T> T: inside不同。另一方面，outside扩展中的符合候选函数的默认实现返回typeable<MyType>，其中MyType尚未上传到inside ...

但是，以下代码或其中的一些变体可以表达您的意图（据我所知），而不会使编译器瘫痪：

struct Typeable<T> {
    init(_: T) {}
}

extension Typeable : CustomStringConvertible {
    var description: String { return "I'm a \(self.dynamicType)" }
}

protocol InsideType {
    func asTypeableInside() -> Typeable<Self>
}

protocol OutsideType : InsideType {
    func asTypeableOutside() -> Typeable<Self>
}

extension OutsideType {
    func asTypeableInside() -> Typeable<Self> {
        return asTypeableOutside()
    }
}

struct Outside {}

extension Outside : OutsideType {
    func asTypeableOutside() -> Typeable<Outside> {
        return Typeable(self)
    }
}

...具有以下属性：

let o = Outside()
let x = o.asTypeableOutside()
print( o )                                       // prints: Outside()
print( x )                                       // prints: I'm a Typeable<Outside>
o is InsideType                                  // always true
x is Typeable<InsideType>                        // always false

Typeable(o) is Typeable<Outside>                 // always true
Typeable(o) is Typeable<OutsideType>             // always false
Typeable(o) is Typeable<InsideType>              // always false

......请记住：

5 is CustomStringConvertible                     // always true
Typeable(5) is Typeable<CustomStringConvertible> // always false

Answer 2

typealias MyType : inside协议中的outside似乎在outside扩展程序中不可见。我可以通过放置typealias MyType = inside（注意=而不是:）来获得编译扩展，但这会在编译时出现thing结构错误。

很难弄清楚你实际上要做什么，更多的背景将有助于完全掌握手头的问题。

Answer 3

在__myFunction扩展名的outside定义中，未实例化的类型MyType可以是继承inside的任何类型，可以在任何地方实例化{{1}实现了。因此，将outside作为typeable<inside>返回仅仅证明是类型不匹配。

但是，您可以避免错误地更改定义。

typeable<MyType>

Swift 2.0协议扩展 - typealias

3 个答案: