C# 替代Y组合定义

我最近花了一些时间研究Y combinator，我发现它通常（或多或少）定义如下（这是C#，但选择的语言并不重要）：

public delegate TResult selfapplication（selfapplicative r）；
公共静态TResult U（自适用r）
{
返回r（r）；
}
公共静态函数Y（函数f）
{
返回U（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（Func f）
{
返回f（n=>Y（f）（n））；
}

---

后一种定义为什么不那么常见（我还没有在网上找到）？它可能与定义Y本身有关吗？

哈斯凯尔·库里发明了Y组合器来定义和使用非类型lambda演算中的匿名递归函数，定义如下：

Y=λf·（λx·f（x））（λx·f（x））

---

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

我不确定你的问题是什么，但我想，Y组合符和你的解决方案在野外都不常见的原因有两个：

匿名递归函数非常罕见；特别是因为C#对尾部递归没有很好的支持（阅读：根本没有）

在C#中定义伪“匿名”递归lambda有一种更简单的方法（对于未初始化的人来说更可读）：

Func fac=null；
fac=x=>x==0？1:fac（x-1）*x；

诚然，这不是匿名的，但出于实际目的，它“足够接近”

---

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

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

Fact(0) -> 1

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

这很好，只是在Erlang世界中，这现在是一个命名函数“Fact”，当调用该方法时，程序将通过重载“fall”，直到找到与参数匹配的第一个函数。在C#中没有与这个确切的构造等价的东西，因为C#不支持基于值选择重载

---

诀窍是以某种方式获得可以传递给函数的函数引用。有很多方法，所有这些都需要在某个地方预先存在引用。如果不能按名称引用该函数，那么FP combinator函数的类型是

FuncOh good the Y combinator。我故意避开了我们课程的那一部分，。。我的脑子里乱七八糟的。但是+1，好问题。这是一个不动点组合，但我不确定它是否真的是Y组合。我也很好奇，让我们看看更有知识的人怎么说……Y组合器不是用来实现递归的吗？也就是说，你不能用它来实现recursion@Lou佛朗哥：哇！是的，听起来不错
Y
允许在一种不支持递归的语言中实现递归，只要该语言支持高阶函数。递归地定义
Y
违背了它最初的目的（尽管它在某些情况下仍然有用）。您的定义看起来就像
fix
函数的Haskell定义：
fix f=let x=f x in x
。即使是Scheme中定义的Y-combinator也不是“匿名的”；您必须调用函数SOMETHING才能在方法中引用它，方案说明与这里发生的情况非常接近（定义
fac
存在，然后创建一个使用
fac
的lambda，并将其分配给
fac
）。@Keith：“您必须调用函数SOMETHING才能引用它”–你真的没有：
Y（f=>x=>x==0？1:x*f（x-1））（5）==120
。这与我的示例根本不同，因为它仍然适用于不可变变量，也就是说，当您无法像我在代码中所做的那样重新定义
fac
的含义时……但当然，这是通过将“匿名”函数绑定到封闭lambda的参数符号（
f
）来“欺骗”的，虽然简单，但在制作副本时存在问题，如下所述：
Func<int, int> fac = null;
fac = x => x == 0 ? 1 : fac(x - 1) * x;

Fact(0) -> 1

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

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

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