Question

我最近花了一些时间在Y组合器周围缠绕我，我发现它通常定义（或多或少）如下（这是在C＃中，但选择的语言并不重要）：

public delegate TResult SelfApplicable<TResult>(SelfApplicable<TResult> r);

public static TResult U<TResult>(SelfApplicable<TResult> r)
{
    return r(r);
}

public static Func<TArg1, TReturn> Y<TArg1, TReturn>(Func<Func<TArg1, TReturn>, Func<TArg1, TReturn>> f)
{
    return U<Func<TArg1, TReturn>>(r => arg1 => f(U(r))(arg1));
}

虽然这是完美的功能（双关语），但似乎我的定义更简单：

public static Func<TArg1, TReturn> Y<TArg1, TReturn>(Func<Func<TArg1, TReturn>, Func<TArg1, TReturn>> f)
{
    return f(n => Y(f)(n));
}

有没有理由说后一个定义不常见（我还没有在网上找到它）？它可能与根据自身定义Y有关吗？

Answer 1

匿名递归，即使用固定点组合器，在命令式，强类型语言中经常不会出现，原因很简单，因为命名[censored]函数比定义执行该函数的匿名函数更容易。同样的任务。此外，OOA＆amp; D告诉我们，不应该重复在多个地方具有价值的代码;它应该被命名，因此可以从一个共同的地方访问。 Lambdas本质上是一次性的;一种指定几行特定情境的代码的方法，用于更通用的算法，如循环结构。大多数递归算法都具有相当普遍的应用（排序，递归系列生成等），这通常会使您可以更广泛地访问它们。

除了Lambda演算之外，在大多数编程语言中，匿名函数F必须存在才能使用。这排除了函数本身的定义。在一些函数语言（如Erlang）中，函数F使用“重载”定义，其中较简单的函数用作更复杂函数的基本情况：

Fact(0) -> 1

Fact(i) -> Fact(i-1) * i

这很好，除了在Erlang-world中这现在是一个命名函数“Fact”，当调用该方法时，程序将“掉落”重载，直到找到第一个参数（s））比赛。在这个确切的构造中，C＃没有等价物，因为C＃不支持根据值选择重载。

技巧是以某种方式获得对可以传递给函数的函数的引用。有许多方法，所有这些方法都需要预先存在的参考资料。如果您不能按名称引用该函数，则FP-combinator函数的类型为Func<Func<Func<Func<Func<...。 Konrad的方法是最简单的方法，但在C＃中它最终会被破解（它编译但是ReSharper仍然抱怨它可能是InvalidOperationException;无法调用null方法指针）。

这是我用于简单案例的内容，基本上使用委托解决方法无法隐式键入隐式类型的lambda：

public static class YCombinator
{
    public delegate TOut RLambda<TIn, TOut>(RLambda<TIn, TOut> rLambda, TIn a);
    public static Func<T,T> Curry<T>(this RLambda<T,T> rLambda)
    {
        return a => rLambda(rLambda, a);
    }
}

//usage
var curriedLambda = YCombinator.Curry<int>((f, i) => i <= 0 ? 1 : f(f, i - 1)*i)
var shouldBe120 = curriedLambda(5);

您可以声明Curry<TIn, TOut>重载来处理输入类型不是输出类型的情况，例如生成前N个素数的列表;函数P可以递归地定义为产生所有正整数列表的函数，这些正整数不能被任何较小的素数整除。固定点P（1）=＆gt; 2定义了一个基本案例，可以从中定义递归算法（尽管不是非常有效的算法）：

var curriedLambda =
            YCombinator.Curry<int, List<int>>(
                (p, i) => i == 1
                              ? new List<int>{2}
                              : p(p, i - 1)
                                    .Concat(new[]
                                                {
                                                    Enumerable.Range(p(p, i - 1)[i - 2],
                                                                     int.MaxValue - p(p, i - 1)[i - 2])
                                                        .First(x => p(p, i - 1).All(y => x%y != 0))
                                                }).ToList()
                );
        Assert.AreEqual(new []{2,3,5,7,11}, curriedLambda(5));

因而这个难题就出现了;虽然你肯定可以将所有东西都定义为高阶函数，但如果定义为强制而不是功能，那么这个寻宝者会更快。主要加速只是在每个级别定义p（p，i-1），因此每个递归级别不会评估3次。设计用于功能性的智能语言可以帮助您。

Answer 2

我不确定你的问题是什么，但我猜想Y组合器和你的解决方案在野外看不到的原因有两个：

匿名递归函数真的很少见;特别是因为C＃没有很好的（读取：根本没有）支持尾递归。
在C＃中定义伪“匿名”递归lambda的方法更简单（更易于阅读）：
```
Func<int, int> fac = null;
fac = x => x == 0 ? 1 : fac(x - 1) * x;
```
当然，这是不是匿名，但实际上它“足够接近”。

Answer 3

Haskell Curry发明了Y组合器，用于在无类型lambda演算中定义和使用匿名递归函数，定义如下：
Y = λf·(λx·f (x x)) (λx·f (x x))

我的定义违背了Y组合子的最初目的，因为它依赖于C＃对定义递归函数的固有支持。但是，它仍然有用，因为它允许在C＃中定义匿名递归函数。

替代Y组合子定义

3 个答案: