2

我可以使用 Kotlin FP (Lambda, function) 编写 Y-combinator 函数吗？

Y = λf.(λx.f (x x)) (λx.f (x x))

在 JS 中：

function Y(f) {
    return (function (g) {
        return g(g);
    })(function (g) {
        return f(function (x) {
            return g(g)(x);
        });
    });
}

var fact = Y(function (rec) {
    return function (n) {
        return n == 0 ? 1 : n * rec(n - 1);
    };
});

在咖啡中：

coffee> Y = (f) -> ((x) -> (x x)) ((x) -> (f ((y) -> ((x x) y))))
[Function]

coffee> fact = Y (f)  ->(n) -> if n==0 then 1 else n*f(n-1)
[Function]

coffee> fact(10)
3628800

我怎样才能做到这一点？

4

1 回答 1

2

在 Kotlin 中，你应该引入一个额外的接口G，否则你会得到UNCHECKED_CAST警告，因为 Kotlin 是一种静态类型的编程语言而不是动态语言，例如：

typealias X = (Int) -> Int
typealias F = Function1<X, X>
//        v-------------v--- let G reference G recursively
interface G : Function1<G, X>

//  v--- create a G from lazy blocking
fun G(block: (G) -> X) = object : G {
    //                          v--- delegate call `block(g)` like as `g(g)`
    override fun invoke(g: G) = block(g)
}

fun Y(f: F) = (fun(g: G) = g(g))(G { g -> f({ x -> g(g)(x) }) })

val fact = Y({ rec -> { n -> if (n == 0) 1 else n * rec(n - 1) } })

另一个版本将 aFunction1<G, X>转换为 a G，因此它应该抑制UNCHECKED_CAST警告，例如：

typealias X = (Int) -> Int
typealias F = Function1<X, X>
typealias G = Function1<Any, X>

@Suppress("UNCHECKED_CAST")
//                                           v--- cast `g` to `G`.
fun Y(f: F) = (fun(g: Function1<G, X>) = g(g as G))({ g -> f { x -> g(g)(x) } })

val fact = Y({ rec -> { n -> if (n == 0) 1 else n * rec(n - 1) } })
于 2017-07-26T20:18:08.963 回答