11

I'm trying to write a complement function, such that when provided with a function f, it returns a function which, when provided with the same input as f, returns it's logical opposite.

Having put similar code into VS2017, I get no errors, however I'm not yet able to run the code to see if it'll work as expected. My intention was to try this in a repl first, to see if it would do as expected. The code I used there was this:

 public static Func<T, bool> Complement<T>(Func<T, bool> f) { return (T x) => !f(x); } public static bool GreaterThanTwo (int x) { return x > 2; } static public void Main(string[] args) { Func<int, bool> NotGreaterThanTwo = Complement(GreaterThanTwo); Console.WriteLine(NotGreaterThanTwo(1)); }

Here is a link to the same.

Within the repl, I get the error:

main.cs(17,42): error CS0411: The type arguments for method `MainClass.Complement(System.Func)' cannot be inferred from the usage. Try specifying the type arguments explicitly Compilation failed: 1 error(s), 0 warnings compiler exit status 1

I have looked at a few questions on stack overflow which cover the same error message, for instance this and this, but I'm not able to see how they relate to this issue I'm having.

Improve this question
11
  • 1
    The typesystem is unable to determine what <T> is when you call it in your main method, you can 'help' it by specifying the input type to Complement e.g. change Complement(GreaterThanTwo); to Complement<int>(GreaterThanTwo); Commented Jun 20, 2019 at 8:02
  • 1
    @OliverRadini the links explain exactly what's wrong and should be considered duplicates. The compiler can't infer which type to use for Complement. Commented Jun 20, 2019 at 8:02
  • 1
    @OliverRadini because I'm trying to find Eric Lippert's video with the explanation from that 2006 answer. It's missing after MSDN's blog engine change. In any case, it seems that the actual answer is that Complement(GreaterThanTwo) is trying to use a method group, not a Func<int,bool>, which is what confuses the compiler Commented Jun 20, 2019 at 8:08
  • 1
    If we privide explicit Func<T, bool> e.g. Func<int, bool> gt = GreaterThanTwo; var NotGreaterThanTwo = Complement(gt); the code compiles Commented Jun 20, 2019 at 8:13
  • 1
    Typecasting also works: Complement((Func<int, bool>)GreaterThanTwo) Commented Jun 20, 2019 at 8:14

2 Answers 2

Reset to default
10

Complement(GreaterThanTwo) is trying to use a method group, not a Func<int,bool> delegate. This fails because Complement<T> expects a generic delegate.

The call would compile with a Func<int,bool>, eg :

Func<int,bool> cmp= x=>x > 2; var NotGreaterThanTwo = Complement(cmp);

There's an implicit conversion from method groups to delegates which means this works too :

Func<int,bool> cmp= GreaterThanTwo; var NotGreaterThanTwo = Complement(cmp);

Which raises the question why didn't the original code work? An explicit cast also works:

var NotGreaterThanTwo = Complement((Func<int,bool>)GreaterThanTwo);

A method group represents a group of overloaded methods, not just a single method. This means that the compiler has to be able to find which of the available groups to use in any situation.

The rest is supposition as I haven't found a definite reference or design note about this specific case.

The first two method group conversion rules probably explains what's wrong :

  • A single method M is selected corresponding to a method invocation (Method invocations) of the form E(A), with the following modifications:

    • The argument list A is a list of expressions, each classified as a variable and with the type and modifier (ref or out) of the corresponding parameter in the formal_parameter_list of D.
    • The candidate methods considered are only those methods that are applicable in their normal form (Applicable function member), not those applicable only in their expanded form.

  • If the algorithm of Method invocations produces an error, then a compile-time error occurs. Otherwise the algorithm produces a single best method M having the same number of parameters as D and the conversion is considered to exist.

In Complement<T>(Func<T, bool> f) there's no invocation, so the compiler doesn't know which method in the group to pick and convert. It doesn't even know what T is, so it can't know if any of the methods in that group match.

On the other hand this works :

var xx=new []{1,2,3}.Where(GreaterThanTwo);

In this case though, Where's signature is :

public static System.Collections.Generic.IEnumerable<TSource> Where<TSource> ( this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,bool> predicate);

and the type argument is already available from IEnumerable<TSource>.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

We started commenting at the same time, looked through the same docs and posted basically the same answer around the same time :)
Many thanks for the comprehensive answer, which makes it clear what the problem is here
@OliverRadini frankly, the definite answer would be a link to a specific rule or explanation from Jon Skeet or Eric Lippert. I'm not a language lawyer so I'm not sure about the deeper reasons. I don't even think about method groups conciously until I hit compilation errors like this one
@CamiloTerevinto guess we've been bitten by that error often enough that we recognize it's not that simple...
9

From What is a method group in C#?

A method group is the name for a set of methods (that might be just one) - i.e. in theory the ToString method may have multiple overloads (plus any extension methods): ToString(), ToString(string format), etc - hence ToString by itself is a "method group".

When you use:

Func<int, bool> NotGreaterThanTwo = Complement(GreaterThanTwo);

GreaterThanTwo is a method group. So, this could be true:

public static bool GreaterThanTwo (int x) { return x > 2; } // to make it clear this is something completely different public static bool GreaterThanTwo (Action<bool, string, object> x) { return false; }

So, the compiler cannot infer which specific method you are referring to, and you need to help it by resolving that ambiguity.

How you decide to solve that it's up to you, but there are at least 3 options here:

  1. Specify the generic argument:

    Complement<int>(GreaterThanTwo);

  2. Implicitly convert the method group to the delegate you want:

    Func<int, bool> greaterThanTwo = GreaterThanTwo; var notGreaterThanTwo = Complement(greaterThanTwo);

  3. Explicitly convert the method group to the delegate you want:

    Complement((Func<int, bool>)GreaterThanTwo);
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.