[Question] why covariant type variable isn't allowed in instance method parameter?

[iTakeshi]

I want define a generic class which is covariant with its type parameter, but mypy claims that covariant type parameter in instance method definition is not allowed.

from typing import Generic, List, TypeVar

T = TypeVar("T", covariant=True)

class GenericClass(Generic[T]):
    def __init__(self) -> None:
        self.list: List[T] = []

    def print(self, arg: T) -> None: # <<< mypy raises error on the "T"; Cannot use a covariant type variable as a parameter
        self.list.append(arg)
        print(self.list)

if __name__ == "__main__":
    g: GenericClass[int] = GenericClass()
    g.print(1)

Is there any solution to get around this?

[Michael0x2a]

If your class is covariant, then that means that if Child is a subclass of Parent, then GenericClass[Child] must also be a subclass of GenericClass[Parent].

If so, then that means it must be legal to define a function that looks like this:

class Parent: pass
class Child(Parent): pass
class OtherChild(Parent): pass

def injector(x: GenericClass[Parent]) -> None:
    # Legal, since OtherChild is also a subclass of Parent
    x.print(OtherChild())

But this is a problem! What if we did this?

foo = GenericClass[Child]()
foo.print(Child())

injector(foo)

# Uh-oh: your list no longer contains only Child, it also contains OtherChild instances!
# We broke type-safety.
print(foo.list)

In short, if your class is covariant, then it needs to by-and-large be a read-only type. Mandating that no method can accept an instance of this type variable is one somewhat coarse (but relatively effective) way of doing so.

In this case though, we can actually circumvent the read-only nature of your covariant class by appending directly to your list field. I think this is a bug in mypy, tbh -- if the type variable is covariant, we should probably:

1. Prohibit users from creating any non-final fields of type T
2. Prohibit users from creating any fields (final or non-final) that are generic and are parameterized on T, but are not themselves covariant w.r.t. T.

---

In your case, I'd carefully consider whether you want your class directly read-only, directly write-only, or neither. Then depending on which you want, make your class covariant, contravariant, or invariant respectively and restructure your logic as appropriate.

If you want to, say, make your class both readable and writable but also covariant, I'm afraid you're out of luck. Probably the only recourse left is to add on # type: ignore comments to any lines where mypy reports an error to silence them and carefully write the remainder of your code to avoid the latent type error.

[iTakeshi]

Thank you very much for your super-clear explanation!
I'll carefully check my logic again.