YCombinator not working in Swift

Question

I am trying to create a lambda function as such to get a factorial function but this throws a segmentation fault and errors out. How do I get this working in Swift. Please look at this video for reference on what I am trying to do http://www.confreaks.com/videos/1287-rubyconf2012-y-not-adventures-in-functional-programming

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)

Answer 1

There's a great post by xiliangchen that walks through creating a Y-combinator in Swift. (Technically, this isn't a Y-combinator, since it is explicitly recursive, but it largely does what you want.) Here's an example of that Y function (stripped of its generic specification for clarity):

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

For more on Y-combinators, you can look at this terrific (long) piece by Mike Vanier.

(Note: Using Any is kind of a mess -- I'd recommend steering clear of it whenever you can, especially since you don't need it in this case.)

Answer 2

You can implement a real (without explicit recursion) Y combinator using a recursive type, without any unsafe tricks (credits to Rosetta Code):

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))

Any doesn't really help because Any cannot represent function types.

Update: Starting in Xcode 6.1 beta 3, Any can represent function types, and your code compiles and works correctly.