Sure, you can return a lambda from another lambda:
Func<int, Func<int, int>> makeAdder = x => y => x + y;
Func<int, int> addTen = makeAdder(10);
Console.WriteLine(addTen(20)); // 30
What aspect of the syntax are you having trouble with? I am interested to know how people get this sort of thing wrong because that helps us design the language and documentation better next time.
UPDATE:
well, but you cannot return lambda returning lambda
Sure you can.
Func<int, Func<int, int>> GetAdderMaker()
{
return x => y => x + y;
}
Here we are returning a lambda that returns a lambda. Why do you believe this is impossible?
UPDATE:
Aha, I understand. You believe that the word "lambda" means "delegate". It does not. A lambda is a kind of expression that is convertible to a delegate.
If you want a delegate that returns a delegate then just declare that. That's perfectly legal. For example, here's a delegate called a "combinator" -- a combinator is a delegate which takes itself and returns itself:
delegate D D(D d);
That's a delegate named D which takes a D and returns a D.
You can make a lambda expression that is compatible with this delegate type. For example:
D I = x=>x;
is the Identity combinator. Or
D M = x=>x(x);
is the Mockingbird combinator in Raymond Smullyan's whimsical characterization of combinators.
As you correctly note, there's no way to make a generic Func that is this kind of combinator. I wrote an article about this fact back in 2006:
http://blogs.msdn.com/ericlippert/archive/2006/06/23/standard-generic-delegate-types-part-two.aspx
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…