关于快速通用仿制药

Question

我遇到以下问题：

问题1-通用curring 创建一个名为Worker的协议，其中包含一个名为perform的函数，该协议接受一个函数并返回一个函数； perform必须具有默认实现。 作为参数传递的函数应命名为work，并将符合协议类型的实例作为参数并返回通用类型T。输出函数为（）-> T

struct Person {
    var name: String
    var age: Int
}

protocol Worker {
    func perform<A,T>(work: @escaping (A) -> (T)) -> () -> T
}

extension  Person: Worker {
    func perform<A, T>(work: @escaping (A) -> (T)) -> () -> T {
        return //execution of the function work
    }
}

其结果应该是这样的：

let person = Person(name: "Bob", age: 3)
let work = person.perform(work: {return "\(person.name) is working"})
print(type(of: work)) // () -> String
print(work()) // Bob is working

我认为我必须返回作为参数传递给我的协议功能perform的工作功能的执行。

我在想对吗？如果我是我该怎么办？

我已经读过有关curring和泛型的文章，但是我仍然无法弄清楚。

编辑1：

我修复了有关默认实现的部分，但仍然无法弄清楚如何返回该闭包。

struct Person: Worker {
    var name: String
    var age: Int
}

protocol Worker {
    func perform<A,T>(work: (A) -> (T)) -> () -> T
}

extension  Worker {
    func perform<A,T>(work: @escaping (A) -> T) -> () -> T {
        return {}
    }
}

我回到我的教科书，他们给了我以下关于使用函数的示例：

func curry<A, B, C>(_ f: @escaping (A, B) -> C) -> (A) -> (B) -> C {
    return { x in { y in f(x, y) } }
}

所以在我看来，函数的返回应该是：

1. 没有参数的闭包（）
2. 内部带有一个闭包，该闭包接收传递给工作的参数。

喜欢这个：

return {() in {x in work(x)}}

编译器给我以下错误：

Cannot convert return expression of type '() -> (A) -> T' to return type '() -> T'

我不明白为什么会这样，因为内部闭包

{x in work(x)}

我认为应该返回类型T的值，因为它是函数工作的执行，但是它返回的是（A）-> T。

我想念什么？

Answer 1

作为参数传递的函数应命名为work，并将符合协议类型的实例作为参数作为参数

Swift使“符合协议的类型”可作为Self使用。因此，work的参数应为Self，而不是A。您根本不需要A类型。

protocol Worker {
    func perform<T>(work: @escaping (Self) -> T) -> () -> T
}

给出该签名，我们如何编写默认实现？

我们必须返回一个返回T的函数。

我们只能通过调用T来创建work。
• 我们必须将Self传递给work。
• 唯一可用的Self是self。

因此，这是唯一合理的默认实现：

extension Worker {
    func perform<T>(work: @escaping (Self) -> T) -> () -> T {
        return { work(self) }
    }
}