Unpacking multiple TypeVarTuples

[Zomatree]

PEP 646 says that you cannot unpack multiple TypeVarTuples at once, but i cant think of any reason for this limitation, there shouldn't be any ambiguity in it like with having multiple variadic generics which what the reason links to.

A simple use-case for this is combining tuples together:

Ts = TypeVarTuple("Ts")
Ts2 = TypeVarTuple("Ts2")

def concat(a: tuple[*Ts], b: tuple[*Ts2]) -> tuple[*Ts, *Ts2]:
    ...

Another language with variadic generics is C++ which does support this:

template<typename... A, typename... B>
auto concat(std::tuple<A...>, std::tuple<B...>) -> std::tuple<A..., B...>;

[erictraut]

The problem is that if a type such as tuple[*Ts, *Ts2] were used to annotate an input parameter, there would be no way to determine which arguments map to which TypeVarTuple.

def func(*a: *tuple[*Ts, *Ts2]) -> Union[*Ts, *Ts2]:
    ...

func(1, 2, 3, 4)

[Zomatree]

C++ requires that one of them be explicit or deduced:

func[int, int](1, 2, 3, 4, 5)  # tuple[int, int] | tuple[int, int, int]

[Viicos]

The problem is that if a type such as tuple[*Ts, *Ts2] were used to annotate an input parameter, there would be no way to determine which arguments map to which TypeVarTuple.

This is a valid when using TypeVarTuple indeed. However, I'm wondering if it could at least be supported when not using such variables. My use case is I'm trying to type a function taking *args, where at least one of the arguments must be of a certain type, in any order (let's say int):

# Matches `func(1, "a", "b", ...)
@overload
def func(arg: int, *args: str): ...

# Matches `func("a", "b", ..., 1)
@overload
def func(*args: *tuple[*tuple[str, ...], int]): ...

# Matches `func("a", "b", ..., 1, "a", "b", ...), but not valid currently
@overload
def func(*args: *tuple[*tuple[str, ...], int, *tuple[str, ...]]): ...