Partial function applications

[fedeAlterio]

Let's suppouse to have a function like that

int Add (int a, int b);

What I would like to do is write something like

Func<int, int> add2 = Add(2, int);

So basically we need to write the types for all the unspecified parameters. The overload resolution in that way is possible.

With type inference, we could also write something like

var add2 = Math.Add(int, 2);

Also it could be used of course directly like

var numbersPlus2 = new[]{1,2,3}.Select(Math.Add(2,int));

Also it should work with optional parameters and delegates

Task LogError(Exception e, string message = null, [CallerMemberName]  string member = "");

var logError = LogError(Exception).
// logError is a Func<Exception, string, string,Task>

var logError2 = LogError(Exception, member: "nothing").
// logError2 is a Func<Exception, string,Task>

var logError3 = logError2(Exception, null);
// logError3 is a Func<Exception, Task>

[En3Tho]

You don't have to write types if they are not ambiguous with natural lambda types like

var plus2 = x => AddInts(2, x) // Func<int, int> inferred

But there is no syntax to make lambdas even shorter like

var plus2 = AddInts(2, _) // I'm not sure something like this will ever get to the language

[svick]

And if they are ambiguous, you can specify them in the lambda:

var plus2 = (int i) => Math.Add(2, i);

I feel like the proposed syntax is not a significant improvement over that.

[fedeAlterio]

You are right. The main improvement I see is for method with a lot of optional parameters. If you want to set only one of them you have to repeat all the others in the lambda