Types concretized too soon? Not sure what to fix here

[rhelmot]

from fractions import Fraction
from decimal import Decimal

def test1() -> set[Fraction | Decimal]:
    a = Fraction()
    b = {a}
    return b

def test2() -> set[Fraction | Decimal]:
    a = Fraction()
    return {a}

The first function does not typecheck but the second one does. Mypy suggests adding a type annotation to b on the first function, but it really feels like this is something the type inference should be able to figure out itself. Am I wrong for thinking this, or is this a bug? Is there a different of preventing this narrowing besides "collapse all expressions" or "use an annotation"? I would appreciate one or two sentences of theoretical background on why this is a problem in my code if it is not a bug :)

[erictraut]

Please refer to this documentation. If you have further questions after reading the pyright documentation, feel free to post back here.

[rhelmot]

are these rules derived from any standard or is it simply the way pyright works? i.e., if one built a slower type checker that didn't have limitations around how often to apply bidirectional inference, would its marking test1 as valid be an error?

[erictraut]

Type inference behaviors are not generally covered by the Python typing spec. Every type checker needs to make certain assumptions about type inference behaviors. Pyright's assumptions are largely in alignment with other type checkers for Python and other languages (like TypeScript).

One rule that is generally followed is that the type of an object is established at the time it is constructed, and it cannot be changed after that point. In your code example, the expression {a} constructs a new set object. The type of this object must be established at the time it is constructed, and all references to that object from that point onward need to honor that type. If it is constructed as a set[Fraction], then all subsequent operations performed on this object must be compatible with set[Fraction]. Once the type of an object is established, it cannot be treated as an incompatible type.