C# 中 Lambda/LINQ 表达式的高级函数混淆

Question

不确定如何描述这个问题，所以标题可能是错误的。

正在阅读一些代码示例，但对以下返回函数感到困惑：

Func<Func<int , bool>, Func<int , int>, Func<int , int>> Loop = null ;
Loop = (c , f ) => n => c(n) ? Loop(c , f ) ( f (n)): n;
Func<int , int> w = Loop(n => n < 10 , n => n + 2); 
var r = w(2); 
var s = w(3);
Console . WriteLine ("{0} {1}" , r , s );

我知道当 c(n) 评估为 true 时，此函数将返回 Loop，但我不明白 Loop(c,f) (f(n)) 的评估方式 - 它们是否都被传递回 Loop ?我曾尝试在 Linqpad 中运行转储，但我只是不明白该位是如何运行的。

任何帮助将不胜感激，理解这可能是一个愚蠢的问题！

Answer 1

尝试理解它的一种方法是从小处着手：基本循环 1-10，增量为 +1。

 Func<int,int> basicLoop = null;
 basicLoop = n => n < 10 ? basicLoop(n+1) : n;

这很简单 - basicLoop 是基于参数 n 返回 n（对于 n >= 10）或使用递增参数调用自身的函数。所以basicLoop(8) 计算为：

• basicLoop(8) 8 basicLoop(8+1) 得到结果
• basicLoop(9) 9 basicLoop(9+1) 得到结果
• basicLoop(10) 10 == 10，因此返回 n，即 10。
• basicLoop(9) 得到结果 10（来自 basicLoop(10)）并返回它
• basicLoop(8) 得到结果 10（来自 basicLoop(9)）并返回它

现在我们要将条件作为参数传递给循环。这意味着我们的“循环”Func 将需要在每次迭代中传递该条件：

该条件的类型显然是（类似于n<10）-Func<int, bool>。所以现在我们有了一些将Func<int,bool> 作为参数并返回与我们原来的basicLoop 相同的值。因此它将是一个参数和一个结果的Func：

Func<Func<int, bool>, Func<int,int>> condLoop = null;

condLoop 是一个参数的函数 - 所以在定义时我们接受参数：condLoop = (condition) => ...。

我们需要替换原来basicLoop中的条件：n => n < 10 ? ...变成n => condition(n) ? ...。

最后一部分是替换basicLoop(n+1) - 我们有condLoop 函数，当您将条件传递给它时，它返回等效于basicLoop。幸运的是，我们的条件在迭代之间没有改变，我们已经有了它 - condLoop(condition) 相当于 basicLoop。把它们放在一起：

condLoop = (condition) =>
   n => condition(n) ? 
      condLoop(condition) (n + 1) :
      n; 

跟踪调用condLoop(x => x < 5)(4)

• condLoop(x => x < 5)(4) - 条件是x => x < 5，n = 4 所以当condition(4) 被调用时 x = 4，4 condLoop 并增加 n - condLoop(x => x < 5)(4 + 1) 以获得结果
• condLoop(x => x < 5)(5) - 条件是 x => x < 5, n = 5 所以当 condition(5) 被调用时 x = 5, 5 n 这是 5
• 返回condLoop(x => x < 5)(4) - 作为condLoop(x => x < 5)(5) 的结果返回5

使用类似的逻辑添加函数来增加值 - 现在每次迭代都需要传递 condition 和 increment 函数（c 和 f 在原始帖子中）。

Answer 2

C# 的匿名委托声明语法会导致混淆，所以我打算用 F# 的函数类型语法重写它。

(int -> bool) -> (int -> int) -> (int -> int)

所以这是一个接受两个函数并返回一个函数的函数。它接受的第一个函数是谓词，第二个可能是映射，最后它返回一个接受 int 的函数以返回一个 int。

Loop = (c , f ) => n => c(n) ? Loop(c , f ) ( f (n)): n;

上述签名的实现。正如预期的那样，它需要两个参数，即 c 和 f。我们希望它返回一个函数，这里是：

n => c(n) ? Loop(c,f) (f (n)) : n;

我可以想象 Loop(c,f) (f (n)) 部分最让你失望。调用 Loop 的结果是一个接受整数并返回整数的函数。 n 是一个整数，f 是一个接受整数并返回整数的函数。在w 的条款中，它将该整数增加2。因此，给定n 为2，如第一个示例所示，您将传递f(n) 的结果2 + 2，作为新的n。只要 c(n) 解析为 true，就会继续迭代，n 每次增加 2，直到大于等于 10。

Answer 3

“我知道当 c(n) 计算结果为真时，此函数正在返回循环，但我不明白 Loop(c,f) (f(n)) 是如何计算的” - 函数不返回Loop。函数是Loop，它返回一个Func<int, int>。

所以，Loop 是一个将两个函数作为输入并返回第三个函数的函数。它的签名Func<Func<int , bool>, Func<int , int>, Func<int , int>> 显示了这一点。

现在，Loop = null 在第一行，这样当Loop 在第二行实际定义时，它可以递归调用自身。

那么，Loop 基本上是一个返回函数n => c(n) ? Loop(c, f)(f(n)) : n 的函数。也就是说，Loop 将返回一个函数，给定未来的n，当c(n) 为true 和n 为false 时将返回Loop(c, f)(f(n))；

w 是Loop 使用参数n => n < 10 和n => n + 2 时的返回函数。

因此，将这些替换为 Loop，您可以像这样定义 w：

Func<int, int> w = null;
w = n => n < 10 ? w(n + 2) : n;

现在可以改写成这样：

int w(int n)
{
    while (n < 10)
    {
        n += 2;
    }
    return n;
}

希望这种进展很容易看到。