Ios 问题：将接受转义闭包的闭包传递给接受该类型闭包的函数

在旧的swift世界（我相信是2.0），我有以下Y-combinator实现

func Y<T, R>( f: (T -> R) -> (T -> R) ) -> (T -> R) {
    return { (t: T) -> R in
        return f(self.Y(f))(t)
    }
}

这个想法是，当“sendData”通知的观察者收到他的响应时，他会向类发送一个包含我的Y-combinator和重复闭包的通知。“sendData”通知的观察者的所有实例收到其数据后

self.responses_received == responses_expected

这是真的，我们不会再调用f（）

现在，我的问题是，转换成Swift 3.0迫使我根据Y的定义将“f”的类型显式声明为@escaping，如下所示：

func Y<T, R>( _ f: @escaping ((T) -> R) -> ((T) -> R) ) -> ((T) -> R) {
    return { (t: T) -> R in
        return f(self.Y(f))(t)
    }
}

我创建了一个简单的示例闭包，只是为了测试，它会给出相同的错误：

let innerClosure = { (f: @escaping ()->()) -> (()->()) in
    return {}
}

let repeatClosure = self.Y(innerClosure)

鉴于以下情况没有问题：

let innerClosure = { (f: ()->()) -> (()->()) in
    return {}
}

let repeatClosure = self.Y(innerClosure)

我从fixit得到建议，强制对类型进行强制转换，而不使用@escaping标记。这可以编译，但感觉不对，而且我还没有实际测试该强制转换在运行时是否可以工作

---

我在这里遗漏了什么？

我在一个操场上有这个代码，它构建时没有任何问题：

class Foo {
  func Y<T,R>(_ f: @escaping ((T) -> R) -> ((T) -> R) ) -> ((T) -> R) {
    return { (t: T) -> R in
      return f(self.Y(f))(t)
    }
  }

  func test() {
    let innerClosure = { (f: ()->()) -> (()->()) in
      print("test")
      return {}
    }

    let repeatClosure = self.Y(innerClosure)
    repeatClosure()
  }
}

Foo().test() // prints "test"

class-Foo{
函数Y（f:@转义（（T）->R）->（（T）->R））->（（T）->R）{
返回{（t:t）->R in
返回f（self.Y（f））（t）
}
}
func测试（）{
让innerClosure={（f:（）->（））->（（）->（））在
打印（“测试”）
返回{}
}
让repeatClosure=self.Y（innerClosure）
重复闭包（）
}
}
Foo（）.test（）//打印“test”

---

您可能希望清理您的构建并重新尝试构建，因为我在我的游乐场上没有收到修复建议。

您的

Y

函数应具有以下签名：

func Y<T, R>(_ f: @escaping (@escaping (T) -> R) -> ((T) -> R)) -> ((T) -> R)

请注意，此

@转义

对应于

Y

签名中的第二个转义。正是此

@转义上的不匹配导致了编译器错误

其余的大部分应该自行解决（一旦您将Dispatch和NSNotificationCenter调用更新为Swift 3）

class Foo {
  func Y<T,R>(_ f: @escaping ((T) -> R) -> ((T) -> R) ) -> ((T) -> R) {
    return { (t: T) -> R in
      return f(self.Y(f))(t)
    }
  }

  func test() {
    let innerClosure = { (f: ()->()) -> (()->()) in
      print("test")
      return {}
    }

    let repeatClosure = self.Y(innerClosure)
    repeatClosure()
  }
}

Foo().test() // prints "test"

func Y<T, R>(_ f: @escaping (@escaping (T) -> R) -> ((T) -> R)) -> ((T) -> R)

self.Y { (f: @escaping () -> ()) -> (() -> ()) in