Why can’t an anonymous method be assigned to var?

by

Others have already pointed out that there are infinitely many possible delegate types that you could have meant; what is so special about Func that it deserves to be the default instead of Predicate or Action or any other possibility? And, for lambdas, why is it obvious that the intention is to choose the delegate form, rather than the expression tree form?

But we could say that Func is special, and that the inferred type of a lambda or anonymous method is Func of something. We’d still have all kinds of problems. What types would you like to be inferred for the following cases?

var x1 = (ref int y)=>123;

There is no Func<T> type that takes a ref anything.

var x2 = y=>123;

We don’t know the type of the formal parameter, though we do know the return. (Or do we? Is the return int? long? short? byte?)

var x3 = (int y)=>null;

We don’t know the return type, but it can’t be void. The return type could be any reference type or any nullable value type.

var x4 = (int y)=>{ throw new Exception(); }

Again, we don’t know the return type, and this time it can be void.

var x5 = (int y)=> q += y;

Is that intended to be a void-returning statement lambda or something that returns the value that was assigned to q? Both are legal; which should we choose?

Now, you might say, well, just don’t support any of those features. Just support “normal” cases where the types can be worked out. That doesn’t help. How does that make my life easier? If the feature works sometimes and fails sometimes then I still have to write the code to detect all of those failure situations and give a meaningful error message for each. We still have to specify all that behaviour, document it, write tests for it, and so on. This is a very expensive feature that saves the user maybe half a dozen keystrokes. We have better ways to add value to the language than spending a lot of time writing test cases for a feature that doesn’t work half the time and doesn’t provide hardly any benefit in cases where it does work.

The situation where it is actually useful is:

var xAnon = (int y)=>new { Y = y };

because there is no “speakable” type for that thing. But we have this problem all the time, and we just use method type inference to deduce the type:

Func<A, R> WorkItOut<A, R>(Func<A, R> f) { return f; }
...
var xAnon = WorkItOut((int y)=>new { Y = y });

and now method type inference works out what the func type is.

More Related Contents:

  1. Why would you use Expression rather than Func?
  2. delegate keyword vs. lambda notation
  3. Why must a lambda expression be cast when supplied as a plain Delegate parameter
  4. How do I invoke an extension method using reflection?
  5. How do C# Events work behind the scenes?
  6. Wrapping StopWatch timing with a delegate or lambda?
  7. What is the Efficiency and Performance of LINQ and Lambda Expression in .Net?
  8. Uses of Action delegate in C# [closed]
  9. What’s the point of a lambda expression?
  10. Lambda Expression using Foreach Clause [duplicate]
  11. Creating a property setter delegate
  12. How to convert Func to Predicate?
  13. Linq – Where().Where() is AND or OR?
  14. How to LINQ List and flatten it using SelectMany?
  15. How to remove a lambda event handler [duplicate]
  16. A method to count occurrences in a list
  17. Using the iterator variable of foreach loop in a lambda expression – why fails?
  18. How to correctly cast a class to an abstract class when using type generics?
  19. Implicit typing; why just local variables?
  20. Lambda expression not returning expected MemberInfo
  21. The purpose of delegates [duplicate]
  22. C# Generics won’t allow Delegate Type Constraints
  23. When would you use delegates in C#? [closed]
  24. Is it possible to intercept Console output?
  25. Fade a panel- Windows forms
  26. Delegates, Why? [duplicate]
  27. Cannot convert lambda expression to type ‘string’ because it is not a delegate type [duplicate]
  28. Task.Factory.StartNew with async lambda and Task.WaitAll
  29. C#: Recursive functions with Lambdas
  30. Subset sum problem

Leave a Comment