Why can't C# compiler infer generic-type delegate from function signature? [duplicate]

Question

This question already has an answer here:

• Why can't C# infer type from this seemingly simple, obvious case 5 answers

I'm working with a function that takes two functions as parameters, and returns a new composed one:

public static Action<T> Compose<T>(Action<T> first, Action second)
{
    return new Action<T>(arg =>
    {
        first(arg);
        second();
    });
}

I've noticed that the compiler complains if I don't specify T, when sending it a static or member function (as opposed to an actual Action<T> object):

static void Main(string[] args)
{
    // compiler error here
    var composed = Compose(Test, () => Console.WriteLine(" world"));
    composed("hello");

    Console.ReadLine();
}

public static void Test(string arg)
{
    Console.Write(arg);
}

The error message:

The arguments for method 'ConsoleTest.Program.Compose(System.Action, System.Action)' cannot be inferred from the usage. Try specifying the type arguments explicitly.

My question: Why can't the type argument be inferred here? The signature of Test is known at compile time, is it not? Is there really some function you could put in place of Test, that would cause its signature to be ambiguous?

_{Footnote: I know I can simply send new Action<string>(Test) instead of Test to Compose (as noted in this question) -- my question is "why", not "how can I do this".}

Answer 1

I suppose it probably has something to do with the fact that, at least from the compiler's perspective, Test is actually a 'method group' until the compiler has determined what it types of parameters it will have. This is true even if there is only one method in the group (only one Test method in the current scope).

Observe:

var composed = Compose<object>(Test, () => Console.WriteLine(" world"));

yields the error:

The best overloaded method match for 'Compose<object>(System.Action<object>, System.Action)' has some invalid arguments

Argument 1: cannot convert from 'method group' to 'System.Action<object>'

But this is fine:

var composed = Compose<string>(Test, () => Console.WriteLine(" world"));

My guess is that the compiler see the both method group expression (Test) and implicitly typed generic method invocation (Compose) as 'unbound' in a sense. It can't fully determine which method to select from the method group from the type 'unbound' signature of the parameter to Compose, and it can't determine which the type type parameter for Compose from the signature. It needs one or the other to be 'bound' in order to compile the whole statement.

Answer 2

It might have to do with covariance. Although the type of the argument of Test is known, you might want to create a delegate of a more specific type.

public class BaseClass { }
public class DerivedClass : BaseClass { }

static class Program
{
    static void Main(string[] args)
    {
        var composed = Compose<DerivedClass>(Test, () => Console.WriteLine(" world"));
        composed(new DerivedClass());

        Console.ReadLine();
    }

    public static void Test(BaseClass arg)
    {
        Console.Write(arg);
    }
}