Tuple Conversion Question

[max-muoto]

I was curious, when converting a unioned tuple into another collection type, such as list or set, you end up with something like set[int | str] as opposed to set[int] | set[str]

from typing import reveal_type


def f(tup: tuple[int, ...] | tuple[str, ...]):
    st = set(tup) 
    reveal_type(st) # Type of "st" is "set[int | str]"

Is there a particular reason why this is the case? The later seems like it would be more accurate. For what it's worth, I don't see any other type-checkers handling this better than Pyright does, but had a case where I had to (what felt pointlessly) break out narrowing into different cases to work around the type-checker with this.

[erictraut]

When a type checker evaluates the type of a call expression, it first evaluates the type of the call (in this case, set). It then tries to determine the return type of the call based on the provided argument list. In the case of your code sample, the call is a constructor, so it's a bit complicated (see this section of the typing spec for details). The set.__init__ method is also overloaded, which adds additional complexity. Let's look at a simpler example.

from typing import Iterable

def func1[T](i: Iterable[T]) -> set[T]:
    return set(i)

def func2(val: tuple[int, ...] | tuple[str, ...]):
    reveal_type(func1(val))  # set[int | str]

When evaluating the type of the call expression func1(val), the type checker's constraint solver needs to find a solution for T. In this case, there is a solution: int | str. That means the resulting return type is set[int | str]. Another acceptable (but less precise) solution for T is object, which is what mypy evaluates in this case, resulting in a revealed type of set[object].