First class polymorphism / Rank-N types

[be5invis]

Given that we have

private void GenericMethod<T, U>(T obj, U parm1)

Which we can use like so:

GenericMethod("test", 1);
GenericMethod(42, "hello world!");
GenericMethod(1.2345, "etc.");

... but it is impossible for now to do this:

public void AnotherMethod(Action<???> method) {
    method("test", 1);
    method(42, "hello world!");
    method(1.2345, "etc.");
}
//...
AnotherMethod(GenericMethod);

...without using reflection/dynamic tricks.

What if we have a ∀?

public void AnotherMethod(∀<T, U>. Action<T, U> method) {
    method("test", 1);
    method(42, "hello world!");
    method(1.2345, "etc.");
}
//...
AnotherMethod(GenericMethod);

[yaakov-h]

What are you trying to express with the upside-down A? I've read your post 3 times and I still don't understand whatever it is that you're trying to suggest.

[be5invis]

@yaakov-h Precisely it is "Rank-N Type".
A link : https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#arbitrary-rank-polymorphism

[jnm2]

So you want an open generic delegate rather than a closed generic delegate? If I understand correctly, the problem with that is type safety can't be checked at compile time and must be checked at runtime. That puts it firmly in the dynamic/reflection world.

Different note, if we get union types and you can take an Action<double | string, double | string>, that would solve your example without needing generics.

[be5invis]

@jnm2 For typechecking, @simonpj (Simon Peyton Jones FRS) has a paper about this:
https://www.microsoft.com/en-us/research/publication/practical-type-inference-for-arbitrary-rank-types/
Also since in C# all functions has declaration maybe you can follow Agda's implicit parameter manner.

[HaloFour]

What is an example use case that this is trying to solve? Why is variance if the Action<...> delagate insufficient?

[be5invis]

@HaloFour In SPJ's paper there are multiple examples of RNT.

[be5invis]

[svick]

I think to do this properly, it would require pretty significant changes to the CLR and, even worse, to the metadata format. The last time that happened, it was in .Net 2.0 for generics. So this would have incredibly high costs.

And it's not hard to work around this limitation by using a custom abstract class instead of open delegate type. Something like (assuming GenericMethod is static; if it's not, you would have to add 2 lines to capture the instance in MyGenericAction):

public abstract class GenericAction2
{
    public abstract void Invoke<T1, T2>(T1 arg1, T2 arg2);
}

sealed class MyGenericAction : GenericAction2
{
    public override void Invoke<T, U>(T obj, U parm1) => GenericMethod(obj, parm1);
}

public void AnotherMethod(GenericAction2 method) {
    method.Invoke("test", 1);
    method.Invoke(42, "hello world!");
    method.Invoke(1.2345, "etc.");
}

The syntax is not as nice as what you're proposing, but it's not that bad.

So this feature has:

1. incredibly high costs
2. limited usefulness (I think most people wouldn't use this very often)
3. existing decent workaround

Because of that, I don't see this happening.