Why is the compiler not able to infer the type of the method?

Question

In the following code:

public class A
{
    public decimal Decimal { get; set; }
}

public decimal Test()
{
    return new List<A>().Sum(SumDecimal);
}

public decimal SumDecimal(A a)
{
    return a.Decimal;
}

The line return new List<A>().Sum(SumDecimal); has an error stating that the SumDecimal is an ambiguous invocation.

Why isn't the compiler able to infer the type of SumDecimal. The following works, however:

return new List<A>().Sum((Func<A, decimal>) SumDecimal);

And of course, the usual lambda way works too:

return new List<A>().Sum(x => SumDecimal(x));

On more experimentation, if I write an extension method of my own:

public static class MyExtensions
{
    public static T MySum<T, T2>(this IEnumerable<T2> ie, Func<T2, T> d)
    {
        return default(T);
    }
}

and call that, the compiler infers just fine:

return new List<A>().MySum(SumDecimal);

I see that IEnumerable<T>.Sum is overloaded for int, decimal etc:

public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
{
  return Enumerable.Sum(Enumerable.Select<TSource, int>(source, selector));
}

and not like how I have defined. But still, is it just that the compiler's type inference is weak and it is not able to figure it out?

Not that it helps but this also works: return new List().Sum(x => SumDecimal(x)); For some reason it is only using the method group that doesn't work. — DoctorMick, Jul 10 '14 at 13:31
@DoctorMick - That is how I usually start writing, and change it to the method group. I was surprised to know that this causes an error here. — manojlds, Jul 10 '14 at 13:34
Interesting, it seems to be getting ambiguity between `System.Func)` and `System.Func )` — DavidG, Jul 10 '14 at 13:36
This also works (and uses the more common lambda syntax): `return new List().Sum(a => SumDecimal(a));` — D Stanley, Jul 10 '14 at 13:44
If no one else takes this one I'll post an answer when I get to the office. Its too complicated to type out on this phone. — Eric Lippert, Jul 10 '14 at 13:44
Think this is similar to @EricLippert's answer here http://stackoverflow.com/questions/7745852/method-inference-does-not-work-with-method-group basically the return type is not considered in overload resolution for method groups. — Kevin Holditch, Jul 10 '14 at 13:47
Doesn't this go back to Eric's [Delegates and Structural Identity](http://blog.coverity.com/2014/06/18/delegates-structural-identity/#.) post - without asking the compiler to generate a lambda, you're left with two incompatible delegate types. — Damien_The_Unbeliever, Jul 10 '14 at 13:47
Seems an exact dupe of @KevinHolditch 's suggestion. If I 'm wrong and noone with a gold C# badge gets to reopen first, ping me and I 'll do it myself. — Jon, Jul 10 '14 at 14:09
@KevinHolditch - Thanks for the link. It was difficult to search for it. — manojlds, Jul 10 '14 at 16:05

Why is the compiler not able to infer the type of the method?

0 Answers0