Question

我可以使用Kotlin FP（Lambda，函数）编写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

我该怎么做？

Answer 1

在Kotlin中，您应该引入一个额外的接口long，否则您将收到app.use(bodyParser.urlencoded({extended : true}))警告，因为Kotlin是静态类型的编程语言而不是动态语言，例如：

{% if all_album%}
    <ul>
        {% for album in all_album %}
        <li><a href = "/music/{{ album.id }}/">{{ album.album_title }}</a></li>
        {% endfor %}
    </ul>>
{% else %}
    <h3>You don't have any album</h3>
{% endif %}

另一个版本将G投射到UNCHECKED_CAST，因此它应该取消 UNCHECKED_CAST 警告，例如：

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

如何使用Kotlin编写Y-combinator函数？

1 个答案: