C＃的lambda - 库里用例库里、lambda

2023-09-03 08:46:33 作者：笑你像狗.

我读This文章，我发现很有意思。

I read This article and i found it interesting.

要概括起来为那些谁不想读了整个帖子。作者实现了一个名为库里这样的高阶函数（没有他的内部类由我重构）：

To sum it up for those who don't want to read the entire post. The author implements a higher order function named Curry like this (refactored by me without his internal class):

 public static Func<T1, Func<T2, TResult>> 
             Curry<T1, T2, TResult>(this Func<T1, T2, TResult> fn)
 {
     Func<Func<T1, T2, TResult>, Func<T1, Func<T2, TResult>>> curry = 
     f => x => y => f(x, y);
     return curry(fn);
 }

这给了我们采取前pression如F的能力（X，Y）例如。

That gives us the ability to take an expression like F(x, y) eg.

Func<int, int, int> add = (x, y) => x + y;

和调用它的F.Curry（）（X）（Y）的方式;

and call it in the F.Curry()(x)(y) manner;

这部分我的理解，我觉得它在一个怪异的方式冷静。我无法左右换我的头实际用例的这种做法。何时何地这种技术是必要的，什么都可以从中得到了什么？

This part i understood and i find it cool in a geeky way. What i fail to wrap my head around is the practical usecases for this approach. When and where this technique is necessary and what can be gained from it?

在此先感谢。

编辑：在最初的3响应据我所知，收益将是在某些情况下，当我们创建一个从咖喱一些参数没有被重新evalued一个新的功能。我建立在C＃这个小测试（记住，我只关心在C＃实现，而不是咖喱理论一般）：

Edited: After the initial 3 responses i understand that the gain would be that in some cases when we create a new function from the curried some parameters are not re evalued. I made this little test in C# (keep in mind that i'm only interested in the C# implementation and not the curry theory in general):

public static void Main(string[] args)
{
    Func<Int, Int, string> concat = (a, b) => a.ToString() + b.ToString();
    Func<Int, Func<Int, string>> concatCurry = concat.Curry();
    Func<Int, string> curryConcatWith100 = (a) => concatCurry(100)(a);

    Console.WriteLine(curryConcatWith100(509));
    Console.WriteLine(curryConcatWith100(609));
}

    public struct Int
    {
        public int Value {get; set;}

        public override string ToString()
        {
             return Value.ToString();
        }

        public static implicit operator Int(int value)
        {
            return new Int { Value = value };
        }
    }

在2个连续调用curryConcatWith100的toString（）方法评价调用两次（一次为每个调用）的值100，所以我没有看到在评价任何好处在这里。我失去了一些东西？

On the 2 consecutive calls to curryConcatWith100 the ToString() evaluation for the value 100 is called twice (once for each call) so i dont see any gain in evaluation here. Am i missing something ?

C＃的lambda - 库里用例库里、lambda

推荐答案