TypeVarTuple with generic ParamSpec

[cdce8p]

I'm trying to use *_Ts as a value for a generic ParamSpec. Pyright currently (v1.1.235) emits an error, saying TupleTypeVars are not allowed in that context. However the inferred type looks correct. Not sure if that's a false-positive or I'm doing something wrong.

from typing import Callable, Generic
from typing_extensions import ParamSpec, TypeVarTuple

_P = ParamSpec("_P")
_Ts = TypeVarTuple("_Ts")


class Job(Generic[_P]):
    def __init__(self, target: Callable[_P, None]) -> None:
        self.target = target


def call_job(
    job: Job[*_Ts],  # or Job[[*_Ts]]  # <-- error
    *args: *_Ts
) -> None:
    reveal_type(job.target)
    job.target(*args)

  test.py:15:14 - error: TypeVarTuple not allowed in this context
  test.py:18:17 - information: Type of "job.target" is "(*_Ts@call_job) -> None"

In principle, I think this is quite similar to the example below which is fine.

def call_soon(
    callback: Callable[[*_Ts], None],
    *args: *_Ts
) -> None:
    reveal_type(callback)  # Type of "callback" is "(*_Ts@call_soon) -> None"
    callback(*args)

[erictraut]

TypeVarTuple is not intended to work with ParamSpec in this manner. PEP 646 does allow TypeVarTuple to be used with an *args parameter in a Callable, but it doesn't allow for specifying a full function signature a'la ParamSpec.

[cdce8p]

I didn't follow the discussion so might be missing some background. Just from looking at the PEP though, I couldn't find a reference explicitly forbidding the usage. It's just not mentioned. What I did find though, was a reference to the unpacking itself

Unpacking a concrete tuple type is analogous to unpacking a tuple of values at runtime.
Tuple[int, *Tuple[bool, bool], str] is equivalent to Tuple[int, bool, bool, str].

This would suggest to me that Job[*Tuple[int, bool, str]] == Job[[int, bool, str]] which would be a valid for ParamSpec.

[erictraut]

*Tuple[int, bool, str] is not equivalent to [int, bool, str]. I think you'll need to find a different approach.

[cdce8p]

Sorry, I implied the brackets. I.e. it should have been Job[[*Tuple[int, bool, str]].

[koffie]

@cdce8p What you mention there is for concrete tuple types. However _Ts = TypeVarTuple("_Ts") is not a concrete tuple type but a type variable tuple.