Jukka, Ivan, Rebecca: You can skip to your names below.
**Constructor argument naming**
> The thing I like about a mouthful like "variadic" is that if you encounter it and don't know what it means you know you need to go look it up.
Hmm, good point. Let's keep this argument in mind if we do decide to use `TypeVar` as the constructor (which I'm still not sure we should).
**Packed vs unpacked**
> I'm a bit uncomfortable introducing a naming convention that makes significant changes to typing interpretation. That feels rather subtle.
> If I were to see `Tuple[Ts]` I'd have to remember that the naming convention tells me that the tuple is variadic. Readability Counts.
> I think the grammar change is for the best. It values explicitness over magic.
Hearing this opinion from Guido in particular updates me significantly. Still, I find myself wondering whether the small improvement in readability (of something that's only likely to be used in library code and therefore not terribly user-facing) is worth the cost to updating the parsers of at least CPython, Mypy, pytype and Pyright.
The main crux for me here is the exact degree of difficulty. Eric, when you said it would be a 'heavy lift', were you thinking mainly because of the complications of concatenation and Map? Based on your experiments in Pyright so far, how difficult would introducing the new grammar be? (**Jukka, Ivan, Rebecca**, it would be super useful to hear your thoughts here too. In case a catch-up would be helpful: the question is, if we wanted to make it so that our new 'variadic type variable' was used as `Ts = TypeVarTuple('Ts'); class Foo(Generic[*Ts]): ...; foo: Foo[int, str] = Foo()`, how hard would that be, considering the new use of the star?)
I've also tried tentatively rewriting it so that a `TypeVarTuple` behaves as if unpacked by default, eliminating the star. Everything does still seem to work, and admittedly the PEP seems much simpler.
> Can you clarify what "no concatenation of variadics" refers to? Does this mean we can't (yet) have `Tuple[int, *Ts]`? Or is that specifically about `Tuple[*Ts1, *Ts2]`. (And what about the same constructs inside `Callable[[<here>], R]`?
I like Eric's proposal of a) only prefixing is allowed, and b) allowing only a single variadic type variable. For `Callable`, I think we shouldn't allow concatenation at all, at least not in this PEP - a) because it's simpler, b) because if we did `Callable[[int, Ts], R]` then the first argument would have to be positional-only, and that feels like it's going to have complications I haven't thought through yet, and c) because I expect most use-cases would be covered by PEP 612. I've updated the draft correspondingly.