替代 Y 组合子定义答案

【问题标题】：Alternative Y combinator definition替代 Y 组合子定义
【发布时间】：2011-01-21 20:51:51
【问题描述】：

我最近花了一些时间来研究 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 有关吗？

【问题讨论】：

天哪，Y 组合器。我故意设法避开了我们课程的那一部分，..我的大脑是这样的。 x__x 但是+1，好问题。
这是一个定点组合器，但我不确定它实际上是 Y 组合器。我也很好奇，让我们看看更有知识的人怎么说……
Y组合子不是用来实现递归的吗？意思是，你不能用它来实现递归
@Lou Franco：糟糕！是的，听起来不错。 Y 将允许人们用一种本身不支持递归的语言来实现递归，只要该语言支持高阶函数即可。递归地定义Y 违背了它的初衷（尽管它在某些情况下仍然有用）。
您的定义看起来就像 fix 函数的 Haskell 定义：fix f = let x = f x in x。 Source (haskell.org)

标签： c# functional-programming y-combinator

【解决方案1】：

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

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

Fact(0) -> 1

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

这很好，除了在 Erlang 世界中，这现在是一个命名函数“Fact”，当调用该方法时，程序将“跌倒”重载，直到找到第一个参数（s ）匹配。由于 C# 不支持基于值选择重载，因此 C# 中没有与此确切构造等效的方法。

诀窍在于以某种方式获得对可以传递给函数的函数的引用。有很多方法，所有这些方法都需要预先存在的参考。如果不能通过名称引用函数，那么 FP-combinator 函数的类型是Func<Func<Func<Func<Func<...。 Konrad 的方法是最简单的，但在 C# 中，它最终成为一种 hack（它可以编译，但 ReSharper 仍然抱怨它可能是 InvalidOperationException；不能调用空方法指针）。

这是我用于简单情况的东西，基本上是使用委托解决方法来解决无法隐式键入隐式类型的 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) => 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 次。一种设计用于功能性工作的更智能的语言将为您做到这一点。

【讨论】：

【解决方案2】：

我不确定你的问题是什么，但我想 Y 组合子和你的解决方案在野外都很少见的原因是双重的：

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

【讨论】：

即使在 Scheme 中定义的 Y 组合子也不是“匿名的”；您必须调用函数 SOMETHING 才能在您的方法中引用它，并且 Scheme 解释与此处发生的情况非常接近（定义 fac 存在，然后创建一个使用 fac 的 lambda 并将其分配给 @987654325 @)。
@Keith：“你必须调用函数 SOMETHING 才能引用它”——你真的不需要：Y(f => x => x == 0 ? 1 : x * f(x - 1))(5) == 120。这与我的示例根本不同，因为它仍然适用于不可变变量，即当您无法像我在代码中所做的那样重新定义 fac 的含义时。
... 当然，这通过将“匿名”函数绑定到封闭 lambda 的参数符号 (f) 来“作弊”。
这个定义虽然简单，但在制作副本时会出现问题，如下所述：blogs.msdn.com/b/wesdyer/archive/2007/02/02/…

【解决方案3】：

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

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

【讨论】：