Is this a MS-compiler issue (Orcas Beta 2) or a mono-compiler one? You might want to let the LINQ team know about it.

I'm really confused with all this lambda stuff lately... it's like a complete new language and
none of the books seem to explain it in normal people's language... feels like you're supposed to be
a rocket scientist to understand some of the books (and I never had this problem before :p)

Anyway, I'm guessing you don't like the fact that the editor is telling you it's wrong? :p

I agree that some of the warnings are annoying, but inferencing the type of the local variable "add" is tricky. If I recall correctly, O'Caml can only infer the type of "add" because the "+" operator only adds integers. To add floating point numbers, you need to use a different operator. C# allows the "+" operator for many different types, so it can't do what O'Caml does.

One possible solution is to do more global inference (i.e. use information about how the variable 'add' is used to refine the type further), but this has some issues. It makes the type inference much more complicated and harder to predict for the programmer. It also wont work all the time.

What Haskell does (roughly) is define an "Num" interface that has addition and subtraction methods. A Haskell-like type inferencer would yield something like "func<T>(T, T) -> T [where T : Num]". C# would probably need a separate "Plusable" interface because there are non-numeric operations that use the "+" operator (for example, string concatenation). A potential problem here is that it's now easy to accidentally use the generic version even when you only really need integer addition; the code will end up performing unnecessary virtual method calls and integer value boxing. Then again, maybe the compiler should trust you and leave the performance-related warnings to tools like FxCop. (Also, a good cross-procedure optimizer can also help.)

I'm really going to put my teeth in all of this :-)
Thnx for the updated information.

Looking at the local "add", I realized that a more specific example also doesn't work.
Func<int, int, int> add = (int a, int b) => a + b; // works fine
var add2 = (int a, int b) => a + b; // CS0815

That second line should work. A lambda expression with explicitly typed arguments should have it's type inferred.
I filed a bug report here: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=294156

We'll see if they give the "Specifications" excuse.