YCombinator在Swift中不工作

我试图创建一个lambda函数来获得阶乘函数，但这会抛出一个分段错误和错误。我怎样才能在Swift中工作呢。请看这段视频，了解我正在尝试做什么

在Swift中，有一种方法可以创建Y组合子。（从技术上讲，这不是一个Y-组合符，因为它是显式递归的，但它在很大程度上实现了您想要的功能。）下面是一个Y函数的示例（为了清晰起见，去掉了它的通用规范）：

有关Y-组合子的更多信息，请参见此

（注意：使用

Any

有点乱——我建议您尽可能避开它，尤其是在这种情况下，您不需要它。）

您可以使用递归类型实现实Y组合器（无显式递归），而无需任何不安全的技巧（归功于）：

struct RecursiveFunc{
设o:RecursiveFunc->F
}
职能

更新：从Xcode 6.1 beta 3开始，
任何
都可以表示函数类型，并且您的代码可以正确编译和工作。
它现在在最新的beta版中工作。您可以将其更新为现代Swift 4.1吗？这听起来可能很傻，但我真的不知道如何编译它
typealias f = () -> ()
typealias g = (Int) -> (Int)
typealias F = Any -> g

let y = { (gen: Any) -> g in
    (gen as F)(gen)
}
let fact = y({ (gen: Any) -> g in
    { (n: Int) -> Int in
        if n == 0 {
            return 1
        } else {
            return n * (gen as F)(gen)(n - 1)
        }
    }
})

fact(10)

typealias G = Int -> Int

func Y (f: G -> G) -> G {
    return {
        (i: Int) -> Int in
        f(Y(f))(i)
    }
}

let factorial = Y { (f: G) -> G in
    { (n: Int) -> Int in
        if n == 0 {
            return 1
        } else {
            return n * f(n - 1)
        }
    }
}

factorial(5)        // 120

struct RecursiveFunc<F> {
  let o : RecursiveFunc<F> -> F
}

func Y<A, B>(f: (A -> B) -> A -> B) -> A -> B {
  let r = RecursiveFunc<A -> B> { w in f { w.o(w)($0) } }
  return r.o(r)
}

let factorial = Y { (f: Int -> Int) -> Int -> Int in
  { $0 <= 1 ? 1 : $0 * f($0-1) }
}
println(factorial(10))