As for PEP-695, maybe variance inference should exempt private members

[Azureblade3808]

class C0[T]:  # T: covariant
    def __init__(self, v: T) -> None:
        self.__v = v
    @property
    def v(self, /) -> T:
        return self.__v

class C1[T]:  # T: invariant
    def __init__(self, v: T) -> None:
        self.__l = [v]
    @property
    def v(self, /) -> T:
        return self.__l[0]

The two classes in the sample are basically identical in their exposed APIs, but the private member __l is making C1.T inferred as invariant instead of covariant. I don't think this is the correct answer. Of course we can use a tuple instead of a list to make the sample work, but in practice we may frequently use data structure with unsuitable covariance (e.g., dict) in the private part. I'd suggest that only public members of a class get into consideration when type-var variance is being inferred.

[erictraut]

The current behavior is consistent with the way that both pyright and mypy calculate and enforce variance for protocols.

I think your argument has merit, but I'd want to understand the consensus of the broader typing community before making such a change. If you'd like, you could start a discussion in the Python typing forum.

[Azureblade3808]

Posted https://discuss.python.org/t/whether-private-members-should-affect-pep-695s-type-var-variance/38959 .

[Azureblade3808]

I think I'm failing at educating others in that post. So let me try a bit more here.

from typing import Callable

class LazyMap[K, V]:  
    __getter: Callable[[K], V]
    __cache: dict[K, V]

    def __init__(self, getter: Callable[[K], V], /) -> None:
        self.__getter = getter
        self.__cache = {}

    def __getitem__(self, key: K, /) -> V:
        try:
            value = self.__cache[key]
        except KeyError:
            value = self.__getter(key)
            self.__cache[key] = value
        return value

@erictraut Do you agree that V on LazyMap should be covariant? Is there a suitable work-around to make V covariant without blurring the type of __cache too much (e.g. using Any)?