Swift 3 泛型函数模糊返回

Question

我需要一个函数来解决类中的不同依赖关系。 但是出现编译错误。 是否可以创建通用函数或 Swift 中有一些编译器约束？

import Foundation

protocol Client: class {
    var description: String { get }
}
final class ImportantPerson : Client {
    var description: String {
        return "Important person"
    }
}

protocol Order: class {
    var description: String { get }
}
final class LastOrder : Order {
    var description: String {
        return "Last order"
    }
}

final class A {

    fileprivate func resolveDependency<T>() -> T {
        return resolve() as T
    }

    private func resolve() -> Client {
        return ImportantPerson()
    }
    private func resolve() -> Order {
        return LastOrder()
    }

}

let a = A()
let client: Client = a.resolveDependency()
let order: Order = a.resolveDependency()

print("Client: \(client.description)")
print("Order: \(order.description)")

编辑：这个问题不是关于 Swift 是否允许创建两个仅在返回类型上有所不同的函数。我知道这是可能的。我认为编译器中存在一些人为约束，但在允许从上下文推断所需类型的基本逻辑中却没有。

Answer 1

让我们设身处地为编译器着想。想象一下，这不会导致错误，并且您有一个具有不同输出的签名。

每当您调用 resolveDependency<T>() -> T 时，编译器都会返回一个类型 T，它是符合您的情况的协议的实例。

在您的代码中，您使用符合相同协议的不同实例调用此方法。在那个阶段，编译器对此一无所知。它只知道你已经传递了一个T 的实例，它需要给你一个T 形状的结果

到目前为止没有问题。只要你执行

return resolve() as! T

编译器会混淆。我有一个T，但我不知道我会打电话给哪个resolve()...我只知道我有一个T。我怎么知道这是Order 还是Client？

为了防止这种混淆，我们有编译器时错误。至少 Swift 是这样。 （我不知道这在其他语言中是如何工作的）

您需要定义具有不同签名的不同方法并相应地转换您的类型以获得相似的结果

fileprivate func resolveDependency<T>() -> T {
  // check if this is an Order
  resolveForOrder()

  // check if this is a Client
  resolveForClient()
}

private func resolveForOrder() -> Order {
  return LastOrder()
}

private func resolveForClient() -> Client {
  return ImportantPerson()
}

这就像试图让汽车修理工修理航天飞机引擎一样。是的，他们都有引擎，他们都靠燃料运转，但机械师只知道如何修理你的汽车引擎，他不是火箭科学家（！）

Answer 2

这段代码运行良好：

import Foundation

protocol Client: class {
    var description: String { get }
}
final class ImportantPerson : Client {
    var description: String {
        return "Important person"
    }
}

protocol Order: class {
    var description: String { get }
}
final class LastOrder : Order {
    var description: String {
        return "Last order"
    }
}

final class A {

    fileprivate func resolveDependency<T>() -> T {
        if T.self == Client.self {
            return resolve() as Client as! T
        } else {
            return resolve() as Order as! T
        }
    }

    private func resolve() -> Client {
        return ImportantPerson()
    }
    private func resolve() -> Order {
        return LastOrder()
    }

}

let a = A()
let client: Client = a.resolveDependency()
let order: Order = a.resolveDependency()

print("Client: \(client.description)")
print("Order: \(order.description)")

但我相信编译器应该自己解决 if else 子句，这并不像我想象的那么难。 当编译器尝试匹配这样的类型时，编译器中也存在一些错误：

    switch T.self {
    case is Client:
        return resolve() as Client as! T
    default:
        return resolve() as Order as! T
    }