parameter list of class covariance

[smithed180]

Hi, I'm trying to do something that I feel ought to be straightforward and I'm running into an issue. I believe the answer is here:
https://mypy.readthedocs.io/en/stable/common_issues.html#invariance-vs-covariance
But the answer, if I understand it, seems exceedingly bizarre to me, so I guess this question is just to confirm that the above link is still correct (and/or that i understood).

my code is more or less doing this:

from typing import List

class p:
    pass

class c(p):
    pass

class b:
    pass

class u:
    def __init__(self, v: List[p]) -> None:
        self.vals = v

l1 = [b()]
bad = u(l1)  #type error, expected

l2 = [c()]
good1 = u(l2)  #type error, not expected
l3: List[p] = [c()]  #somehow this is just fine even though the above isn't
good2 = u(l3)  #still good

l4 = [p()]
good2 = u(l4)  #good as expected

l2 and l3 are identical, but have different type behavior. That link above seems to say there is no (built-in) way to say "my function takes a list of p or any of its children". Is this really right?

Thanks :)

[erictraut]

Yes, this is all expected. The case of l2 and l3 are different in that you are providing an explicit type annotation for l3.

For details, refer to the following documentation:
https://github.com/microsoft/pyright/blob/main/docs/type-inference.md
https://github.com/microsoft/pyright/blob/main/docs/type-concepts.md

[smithed180]

thanks for replying. this all makes sense in general, but where I'm having difficulty agreeing is specifically with classes (I say this since a huge swath of examples for typing deals with single values like str vs int vs float).

If I say my function accepts a list of a parent class, the assumption is that I'm writing against the interface of that parent class. Shouldn't that be enough to say "any function that operates on parent P will also work with child C"?

[erictraut]

No, that wouldn't be type safe. Lists are mutable, so the type parameter is invariant.

See https://github.com/microsoft/pyright/blob/main/docs/type-concepts.md#generic-types for details. Or check out PEP 483.

If the function in question is not going to mutate the list, then you can specify that the input parameter is a Sequence[P], and you can then pass a List[C] to it.

[smithed180]

Ok, thank you, i get it now :)

For anyone else having trouble with this question, the key section that made me understand was this one:

def append_pi(lst: List[float]) -> None:
    lst += [3.14]

my_list = [1, 3, 5]  # type: List[int]

append_pi(my_list)   # Naively, this should be safe...

my_list[-1] << 5     # ... but this fails

its in the subtype relationships section of 483 linked by eric above.