Invariance and lists

[Molkree]

I'm a bit confused about invariance in relation to lists.

I get why this produces an error, types should match exactly:

e: list[int] = [3, 4]
f: list[int | None] = e  # Error

At the same time this doesn't produce an error:

f: list[int | None] = [3, 4] * 2

I guess strictly speaking [3, 4] * 2 has type list[int] but is it implicitly expanded (by Pyright/mypy) to the type of the lhs if possible?

Then why this again produces an error?

f: list[int | None] = [3, 4] * 2 * 2

[erictraut]

You may find this documentation useful. In particular, take a look at the section on bidirectional type inference.

[Molkree]

Thank you, this confirms my assumptions but doesn't really answer the last question. Any hints here?

[erictraut]

In general, bidirectional type inference doesn't work for expressions that involve operators that are backed by magic methods. The * operator is an example of this. However, pyright includes specific special-case handling for expressions that use a * operator with a list expression on the LHS and a literal integer type on the RHS. This case is sufficiently common to justify adding a special case, although I did so reluctantly because such special cases result in inconsistencies and invite questions like the one you posted. :)

Your last example falls outside the bounds of the special-case logic, so bidirectional type inferences is not applied in that case. It does apply if you add parenthesis around (2 * 2).

[Molkree]

Aha, now I get it, thanks! Looks like mypy follows the same logic in this case.

[Molkree]

pyright includes specific special-case handling for expressions that use a * operator with a list expression on the LHS and a literal integer type on the RHS

From my experiments it doesn't have to be a literal integer type, just int is enough (as a variable).

[erictraut]

Yes, you're right. The pattern typically involves an integer literal, but the special-case logic handles any int (literal or not).