Variance of TypeVar is incompatible with base class

[LeeeeT]

Pyright gives me an error for the following code:

from typing import Generic, TypeVar


T_contra = TypeVar("T_contra", contravariant=True)


class Base(Generic[T_contra]):
    def method(self, arg: T_contra) -> None:
        ...


class Derived(Base[frozenset[T_contra]], Generic[T_contra]):  # error here
    def method(self, arg: frozenset[T_contra]) -> None:
        ...

Type "T_contra@Derived" cannot be assigned to type variable "_T_co@frozenset"
    Variance of TypeVar "T_contra@Derived" is incompatible with base class "frozenset"

However, I think this code is correct. The current annotations mean I can assign:

• Derived[float] to Derived[int];
• (arg: frozenset[float]) -> None to (arg: frozenset[int]) -> None;
• frozenset[int] to frozenset[float];
• int to float.

Surprisingly, if I use covariant TypeVar in Derived...

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


class Derived(Base[frozenset[T_co]], Generic[T_co]):
    def method(self, arg: frozenset[T_co]) -> None:
        ...

...I get no errors at all. But this code is completely wrong since it violates Liskov substitution principle.

pyright 1.1.277

[erictraut]

Pyright is correct here, so this isn't a bug. The variance of T_contra is inconsistent with the variance of the TypeVar for frozenset, so you cannot use it in this location.

You need to use TypeVars with different variances for Base and Derived, like this:

from typing import Generic, TypeVar

T_contra = TypeVar("T_contra", contravariant=True)
T_co = TypeVar("T_co", covariant=True)


class Base(Generic[T_contra]):
    def method(self, arg: T_contra) -> None:
        ...

class Derived(Base[frozenset[T_co]]):
    def method(self, arg: frozenset[T_co]) -> None:
        ...

[LeeeeT]

Your code violates Liskov substitution principle. Here's why:

from typing import Generic, TypeVar

T_contra = TypeVar("T_contra", contravariant=True)
T_co = TypeVar("T_co", covariant=True)


class Base(Generic[T_contra]):
    def method(self, arg: T_contra) -> None:
        ...

class Derived(Base[frozenset[T_co]]):
    def method(self, arg: frozenset[T_co]) -> None:
        ...

class DerivedInt(Derived[int]):
    def method(self, arg: frozenset[int]) -> None:
        print("expected subtype of int, got:", next(iter(arg)).__class__.__name__)


def f(d: Derived[float]) -> None:
    d.method(frozenset({3.14}))


f(DerivedInt())  # there should be an error
# but there isn't, because Derived is covariant

Prints:

expected subtype of int, got: float

[erictraut]

Thinking about this more, you are correct that pyright should not allow frozenset[T_co] as a type argument for Base but should accept frozenset[T_contra].

This will be fixed in the next release.

[erictraut]

This is included in pyright 1.1.279, which I just published. It will also be included in a future version of pylance.

[LeeeeT]

@erictraut, the same bug is happening again after upgrading to pyright 1.1.298.

[erictraut]

@LeeeeT, hmm, that's strange. I added a unit test to detect regressions when I fixed this previously. I take a closer look. Reopening the issue.

[LeeeeT]

@erictraut, I created the following exhaustive test case:

from typing import Generic, TypeVar

T_co = TypeVar("T_co", covariant=True)
T_contra = TypeVar("T_contra", contravariant=True)

class Co(Generic[T_co]): ...

class Contra(Generic[T_contra]): ...


class CoToContra(Contra[Co[T_contra]]): ...

class ContraToContra(Contra[Contra[T_co]]): ...

class CoToCo(Co[Co[T_co]]): ...

class ContraToCo(Co[Contra[T_contra]]): ...

It ensures the following rules (preudocode):

• Co[Contra] -> Contra
• Contra[Co] -> Contra
• Co[Co] -> Co
• Contra[Contra] -> Co

So, you can think about it like this:

• When you parameterize a covariant or a contravariant type with a type of the same variance you get a covariant type back.
• Similarly, when you parameterize a type with a type of the opposite variance you get a contravariant type back.

For the test case above pyright gives errors for all 4 classes.

Interestingly, if I get rid of inheritance in this example the errors disappear:

from typing import Generic, TypeVar

T_co = TypeVar("T_co", covariant=True)
T_contra = TypeVar("T_contra", contravariant=True)

class Co(Generic[T_co]): ...

class Contra(Generic[T_contra]): ...


class CoToContra(Generic[T_contra]):
    def f(self, arg: Co[T_contra]) -> None: ...

class ContraToContra(Generic[T_co]):
    def f(self, arg: Contra[T_co]) -> None: ...

class CoToCo(Generic[T_co]):
    def f(self) -> Co[T_co]: ...

class ContraToCo(Generic[T_contra]):
    def f(self) -> Contra[T_contra]: ...

This code ensures the same rules but without using inheritance (uses functions instead to trigger variance checking). Maybe something is going wrong in pyright when handling inheritance?

[erictraut]

This will be fixed in the next release. I incorporated your test case — thanks!

[erictraut]

This is included in pyright 1.1.300, which I just published. It will also be included in a future release of pylance.

[LeeeeT]

Sorry, @erictraut, your fix didn't help. You incorporated my second test example which, as I said, worked fine. The one that uses inheritance is the one that was failing in pyright 1.1.298 and is still failing on version 1.1.300, but now pyright gives errors for only 2 classes, not 4.

[erictraut]

Please open a new bug with a clear example of what you think is going wrong. This one has already been marked fixed and closed twice.