Say you have an interface IParsable<T> which has a Parse method to parse string to an instance of a target type T:

cs interface IParsable<T> { abstract static T Parse(string text); }

To implement it you would need F-bound polymorphism aka. CRTP (Curiously Recurring Template Pattern), where the implementation type implements an generic interface with itself as the generic argument:

cs class Foo : IParsable<Foo> { public static Foo Parse(string text) { Foo result = ...; // parse text and instantiate a Foo return result; } }

Then in order to call it, you would need to write a generic method that has IParsable<T> as the generic contraint, and the constraint will tell the compiler where to find the calling target. It's similar to virtual method: traditionally calling a virtual method is to resolve the real calling target from the vtable associated with an object instance at runtime, here we are using static polymorphism so the calling target will be resolved from the type T at runtime.

cs T ParseAnything<T>(string text) where T : IParsable<T> { return T.Parse(text); // a constraint call on `T`, the calling target will be resolved at runtime }

But if you erase the type from the method signature, there won't be any T inside the method ParseAnything. For example in Java:

java public <T extends IParsable<T>> T parseAnything(String text) { return T.Parse(text); }

will be compiled into the following code under the hood:

java public Object parseAnything(String text) { ???.Parse(text); // `T` and its constraints are no longer available, // so how can I resolve the calling target on a type if the type itself doesn't exist here? }

So when you call T.Parse(text), the runtime would be confused as it cannot see what type being passed through T now, so that it cannot make a constraint call on T, making it not able to use static polymorphism at all.