Swift：关于泛型函数和关联类型的问题

问题描述

比如说，我有一个关联类型的协议：

protocol Model {
    associatedtype ModelType
}

并且有一个符合此协议的通用结构：

struct Implementation<T>: Model {
    typealias ModelType = T
}

现在，我想向该结构添加一个实例方法，该方法接受并返回抽象 Model 类型的值：

struct Implementation<T>: Model {
    typealias ModelType = T
    func test<M: Model>(model: M) -> M {
        return model
    }
}

这编译没有错误。我想更进一步，确保 model 参数和 test(model:) 方法的返回值与调用此方法的 ModelType 实例具有相同的关联 Implementation在：

struct Implementation<T>: Model {
    typealias ModelType = T
    func test<M: Model>(model: M) -> M where M.ModelType == T {
        return model
    }
}

编译没有错误，并且按预期工作。如果有第二种类型符合 Model...

struct Alternative<T>: Model {
    typealias ModelType = T
}

...，只有当它具有相同的关联 test(model:) 时，我才能将这种类型的实例传递给 ModelType 方法。即下面的代码编译...

let implementation = Implementation<Int>()
let alternativeA = Alternative<Int>()
_ = implementation.test(model: alternativeA)

...，而以下代码：

let implementation = Implementation<Int>()
let alternativeB = Alternative<String>()
_ = implementation.test(model: alternativeB)

... 编译失败，错误提示：

实例方法“test(model:)”要求类型“Int”和“Alternative.ModelType”（又名“String”）是等价的

现在，在某些情况下，test(model:) 方法应该返回 self。如果我将其更改为（始终）返回 self，但是...

struct Implementation<T>: Model {
    typealias ModelType = T
    func test<M: Model>(model: M) -> M where M.ModelType == T {
        return self
    }
}

...，我会收到一个错误提示，

无法将类型为“Implementation”的返回表达式转换为返回类型“M”

这令人困惑，因为很明显，self 的类型应该匹配所有给定的约束。 （或者不是？）

该错误实际上与 where 子句无关。如果我放弃它......

struct Implementation<T>: Model {
    typealias ModelType = T
    func test<M: Model>(model: M) -> M {
        return self
    }
}

...，错误仍然存​​在：

无法将类型为“Implementation”的返回表达式转换为返回类型“M”

为什么我会收到此错误，以及如何从此方法返回 self？

（顺便说一下，我使用的是 Swift 5.3.2，以防万一。）

解决方法

您收到此错误，因为确实 self 不匹配所有给定的约束。通过声明 func test<M: Model>(model: M) -> M where M.ModelType == T 你只是说这个类型 M（它只存在于调用你的 test 函数的上下文中）是一个 Model，它是 { {1}} 与 ModelType 的 ModelType 相同。然而，这并不意味着 self 和 Self 是等效的。

使用上面的类型的一个小例子：

假设 M 是 self 的一个实例。在调用 Implementation<Int> 的上下文中，test(model:) 可以是 M 或 Implementation<Int>。在第一种情况下返回 Alternative<Int> 不会有问题，因为两个实例具有相同的类型。但是，在第二种情况下，您可以将 self 分配给 Implementation<Int>。

Alternative<Int>

我确信有一种方法可以在 Swift 中完成您想要实现的目标，但解决方案完全取决于那是什么。

,

泛型函数总是尝试从上下文和编译时推断类型

// func test<M: Model>(_ model: M) -> M
test(Alternative<Int>())

被视为具体类型函数

func test(_ model: Alternative<Int>) -> Alternative<Int>

所以你做不到

struct Implementation<T>: Model {
    typealias ModelType = T
    func test(_ model: Alternative<Int>) -> Alternative<Int> {
        return self // Implementation<T>,type mismatch
    }
}

此外，如果您在类型中为泛型函数使用泛型约束

struct Implementation<T>: Model {
    typealias ModelType = T
    func test<M: Model>(_ model: M) -> M where M.ModelType == T {
        return model
    }
}

For Implementation<Int> 翻译成类似的东西

extension Implementation where T == Int {
    func test<M: Model>(_ model: M) -> M where M.ModelType == Int {
        return model
    }
}

约束阻止您调用

Implementation<Int>().test(Alternative<String>())

也许这个提议会让你解决这个问题，但我认为它仍然是不可能的，因为这种情况在编译时无法解决。 Proposal

我不确定您是否真的想从您的方法中返回 self 或 model，也许最好将您的模型作为 inout 参数传递。 如果你还想返回 self 你可以这样做

struct Implementation<T>: Model {
    typealias ModelType = T
    func test<M: Model>(_ model: M) -> Self where M.ModelType == T {
        return self
    }
}

你可以重载这个方法让编译器决定（根据上下文）使用什么

struct Implementation<T>: Model {
    typealias ModelType = T
    func test<M: Model>(_ model: M) -> Self where M.ModelType == T {
        return self
    }

    func test<M: Model>(_ model: M) -> T where M.ModelType == T {
        return model
    }
}

但如果 M == Self

顺便说一句，您已经通过创建协议见证人为您的协议创建了一个存在

Protocol wintesses

此外，我不确定您是否真的需要为您的 Model 协议创建一些见证类型，也许您可​​以仅使用具有通用约束的 Implementation<T> 扩展来概括您的工作