Eta reduction should works with implicit operator

[ghostnguyen]

public class Foo<T>
{
    public T1 Process<T1>(Func<T1> fa, Func<T, T1> fb) => default;

    public static implicit operator Foo<T>(T t) => new();

    public Foo<T1> CallProcess1<T1>(Func<T, T1> f) => Process(() => new Foo<T1>(), v => f(v));
    public Foo<T1> CallProcess2<T1>(Func<T, T1> f) => Process(() => new Foo<T1>(), f); // compile error CS0411
}

The methods CallProcess1 and CallProcess2 should be identical but the CallProcess2 gets compile error CS0411: The type arguments for method cannot be inferred from the usage

But it works in this cases:

public class Foo2<T>
{
    public T1 Process<T1>(Func<T, T1> fb) => default;

    public static implicit operator Foo2<T>(T t) => new();

    public Foo2<T1> CallProcess1<T1>(Func<T, T1> f) => Process(v => f(v));
    public Foo2<T1> CallProcess2<T1>(Func<T, T1> f) => Process(f); // compile success
}

[colejohnson66]

Is this actually a language spec issue or is it just a Roslyn bug?

[ghostnguyen]

I think it's a Roslyn bug.

[huoyaoyuan]

It's usually not a compiler bug, but the language spec doesn't allow type inference like this.
C# generally tends to make the inference rules straight. It's helpful with complexity and compilation time.

[ghostnguyen]

But it's working in the second example.

[huoyaoyuan]

Lambdas and delegates are complex because of target-typing natural. I can't give any answer for this case.

[jilles-sg]

I think this is working as intended: f and v => f(v) are not the same. When writing f, the delegate is passed as is and only delegate variance is available (see e.g. https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/covariance-contravariance/variance-in-delegates ). When writing v => f(v), a new delegate may be created and most implicit conversions are available for the argument and the return value.

Another way to see this is that CallProcess2 in the first example must pass a delegate to Process that invokes both the original delegate and the conversion operator. Therefore, the delegate passed to Process cannot be the same as the original delegate.

Implicit conversion operators are not magic at run time. The compiler inserts calls to them, and at run time they are method calls like any other. (With dynamic the call might be inserted at run time.)

On the other hand, delegate variance works because implicit reference conversions do nothing at run time, so the same delegate object can be used.

As for the CS0411 error, try to specify the type arguments. There is no combination of type arguments that makes it work.

[ghostnguyen]

But the main issue still there:
f and v => f(v) should be equal (Func is also a delegate type) and should be used interchangeable as eta reduction.

[colejohnson66]

They're not.

f means to "invoke f and nothing else." If the types aren't compatible, it won't compile. v=>f(v) means to "invoke any conversions necessary to turn v into something that can be passed to f, then invoke f, then invoke any conversions necessary to turn the result into something compatible with the expected return type".

You have to remember that casts are just normal method calls with fancy syntax. Specifically, v => f(v) gets "lowered" as: v => (TResult)f((TInput)v). So, from your first example, v => f(v) gets lowered as v => 'operator Foo<T>'(f(v)). When the casts are made explicit, you can easily see how f and v => f(v) are different methods - because they're different code!

From your second example:

public Foo2<T1> CallProcess2<T1>(Func<T, T1> f) => Process(f);

That gets compiled as: (Foo2<T1>)Process(f); You just don't see that.

[ghostnguyen]

I get how it works currently.

But as I suggest, it should also work in more generic way.

For example,

1. Reduce/convert/normalize Func<> and delegate to the same kind of object if signature match.
2. Then apply the same procedures: Checking override, type match, etc.. and perform the same actions: invoke, implicit convert, etc..

[CyrusNajmabadi]

As I mentioned above:

That would allocate a new delegate, violating the current expectation that you are just passing a specific value along.

[ghostnguyen]

The given value f indeeds a delegate type.