Hello all, There's some overlap between PEP 612 and PEP 646 and I thought it would be good to start a discussion. Sorry if this has already been covered, just trying to catch up! :-) The current draft of PEP 646 includes this example: ``` Ts = TypeVarTuple('Ts') def f(func: Callable[[int, *Ts], Any]) -> Tuple[*Ts]: ... def foo(int, str, float): ... def bar(str, int, float): ... f(foo) # Valid; inferred type is Tuple[str, float] f(bar) # Not valid ``` This is similar to the Concatenate operator PEP 612 introduces. Compare: ``` P = ParamSpec('P') def f1(func: Callable[Concatenate[int, P], Any]) -> Callable[P, Any]: ... Ts = TypeVarTuple('Ts') def f2(func: Callable[[int, *Ts], Any]) -> Callable[[*Ts], Any]: ... ``` Question 1: Do f1 and f2 differ? I'm assuming f2 won't preserve keyword arguments like ParamSpec does and that a function that takes keyword-only arguments would be invalid if matched against a TypeVarTuple. But some language in the PEP mentioning that would be good. Question 2: Should ParamSpec support splatting? Should Concatenate exist at all? That is, in addition to (or instead of) `Callable[Concatenate[int, P], Any]` we spell it `Callable[[int, *P], Any]`. There shouldn't be any parsing / runtime concerns for ParamSpec splatting, since it would just be normal sequence unpacking. If Concatenate is destined to be vestigial, it's not too late to get rid of it! :-) If Concatenate should exist, should `Concatenate[x, Ts]` generally be a synonym for `[x, *Ts]`? Note that Concatenate can't serve as a replacement for PEP 646's proposed Unpack, since you can't spell `def f(*args: Unpack[Ts])` and stuff like `[int, *Ts, float]` becomes awkward. (But as far as I can tell, Unpack / splatting could do everything Concatenate would). Thanks, Shantanu