TypeVarTuple to get a tuple of lists of unknown types: tuple[*list[Ts]]?

[taminomara]

Hi!

Here's a use-case I got recently: I want to accept a tuple of lists, but I don't know beforehand how many lists there will be, or of what type their elements will be.

Here's the equivalent of what I want in C++:

template <typename... Ts>
void process_vecs(std::vector<Ts>... lists);

From what I gather, there's no way to type such function in python:

def process_lists(*lists: *list[Ts]): ...  # can't unwrap `list`
def process_lists(*lists: list[*Ts]): ...  # `list` can't take unwrapped type

I wonder if it's something that people are interested in discussing/implementing. Maybe there are existing discussions that I can help with? I haven't found anything.

[nymous]

Hello!

When typing star-args, the type hint after *args represents the type of one element of the tuple of passed arguments (see the last example of the "Functions" header in mypy docs).
For example:

from typing import TypeVar

T = TypeVar("T")

def process_lists(*lists: list[T]): ...

if you expect a tuple and not star-args, you can still type this like the following (see mypy docs):

from typing import TypeVar

T = TypeVar("T")

def process_lists(lists: tuple[list[T], ...]): ...

I created a Pyright playground and a mypy playground to show the different possibilities. You can click on the reveal_type() or hover on the gutter to see which types are used.
Note however that it seems that Mypy doesn't like when you passe different a tuple of different Ts...

[taminomara]

In your examples, Mypy is correctly highlighting errors at lines 10 and 18.

This is because the signature of f,

T = TypeVar("T")
def f(*args: list[T]) -> T: ...

means "a function that accepts arguments of type list[T]". Note that all lists are expected to have the same element's type.

My question is, however, not about TypeVar, but about TypeVarTuple.

I want to annotate a function that takes lists of different types. For this, I want to annotate type that's contained within a list using TypeVarTuple.

This is an expanded example:

from typing import TypeVarTuple

Ts = TypeVarTuple("Ts")

def get_first_elements(*args: *list[Ts]) -> tuple[*Ts]:
    return tuple(l[0] for l in args)

first_elems = get_first_elements([1, 2, 3], ['a', 'b', 'c'])
print(first_elems)  # (1, 'a')
reveal_type(first_elems)  # tuple[int, str]

And here's an example I've met in a wild:

class Parser(Generic[T]):
    def parse(self, s: str) -> T: ...

class IntParser(Parser[int]): ...

class StrParser(Parser[str]): ...

class TupleParser(Parser[tuple[*Ts]], Generic[*Ts]):
    def __init__(self, *args: *Parser[Ts]): ...
    def parse(self, s: str) -> tuple[*Ts]: ...

result = TupleParser(IntParser(), StrParser()).parse('1 a')
print(result)  # (1, 'a')
reveal_type(result)  # tuple[int, str]

[erictraut]

I don't think there's a way to express that in the current type system. Early drafts of PEP 646 (which introduced TypeVarTuple) included a Map mechanism that may have been able to accommodate this, but Map was removed because PEP 646 was already very complicated. It may be added in a future PEP.