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).