具有返回类型重载的 Swift 泛型函数调用函数

Question

只是一个简单的问题。我有以下代码，效果很好：

class obA: Printable {
    var description: String { get { return "obA" } }
}

class obB: Printable {
    var description: String { get { return "obB" } }
}


func giveObject() -> obA { return obA() }
func giveObject() -> obB { return obB() }

var a: obA = giveObject()
var b: obB = giveObject()

println(a)
println(b)

giveObject 的正确变体被调用，一切正常。当然这只是一个简化的例子，实际上在我的项目中有几十个“giveObject”的重载，所有的返回类型都不同。现在，我想做一个通用函数来解析所有这些东西。那么，下一步：

func giveGeneric<T>() -> T {
    return giveObject()
}

var c: obA = giveGeneric()
println(c)

这抱怨了 giveObject 的使用不明确。我可以理解错误来自哪里，但我不知道如何解决它并使用这样的构造......

Answer 1

首先只是一个注释。

如果giveGeneric 的泛型类型只是T，那么它可以是任何东西（String、Int、...）。那么giveObject()在这种情况下应该如何反应呢？

我的意思是，如果你写：

let word : String = giveGeneric()

在内部，您的通用函数调用如下：

let result : String = giveObject() // Ambiguous use of giveObject

我的解决方案

我声明了一个协议如下：

protocol MyObject {
    init()
}

然后我让你的 2 个类符合协议

class obA: Printable, MyObject {
    var description: String { get { return "obA" } }
    required init() {}
}

class obB: Printable, MyObject {
    var description: String { get { return "obB" } }
    required init() {}
}

终于可以写这个了

func giveGeneric<T:MyObject>() -> T {
    return T()
}

现在我可以使用它了：

let a1 : obA = giveGeneric()
let b1 : obB = giveGeneric()

您决定这是您正在寻找的解决方案还是只是一种解决方法。

Answer 2

即使您为任何可能的类型实现giveObject 函数，这也行不通。由于T 可以是任何类型，giveGeneric 方法无法确定要调用的正确重载。

我能想到的唯一方法是创建一个巨大的 swift，其中包含与您要处理的类型数量一样多的案例：

func giveGeneric<T>() -> T? {
    switch "\(T.self)" {
    case "\(obA.self)":
        return giveObject() as obA as? T
    case "\(obB.self)":
        return giveObject() as obB as? T
    default:
        return .None
    }
}

但我不认为我会使用这样的解决方案，即使枪指着我的头 - 这真的很难看。

如果在所有情况下您都使用无参数构造函数创建实例，那么您可能会创建一个协议并约束 T 泛型类型来实现它：

protocol Instantiable {
    init()
}

func giveGeneric<T: Instantiable>() -> T {
    return T()
}

您可以使用内置类型以及新类型 - 例如：

extension String : Instantiable {
    // `String` already implements `init()`, so nothing to add here
}

let s: String = giveGeneric()

或者，如果您愿意，可以让协议声明一个静态的giveObject 方法，而不是无参数的构造函数：

protocol Instantiable {
    static func giveObject() -> Self
}

func giveGeneric<T: Instantiable>() -> T {
    return T.giveObject()
}

extension String : Instantiable {
    static func giveObject() -> String {
        return String()
    }
}

let s: String = giveGeneric()