from __future__ import annotations
from typing_extensions import TypeVarTuple, Unpack
TensorTs = TypeVarTuple("TensorTs")  # 这里是复数泛型参数，按照惯例使用 Ts
def foo(*args: Unpack[TensorTs]) -> tuple[Unpack[TensorTs]]: ...
x = foo(1, "")
reveal_type(x)  # tuple[int, str]

    class _Func(Protocol):
        @overload
        def __call__(self, arg: Tensor, /) -> Tensor: ...
        @overload
        def __call__(self, *args: Tensor) -> tuple[Tensor, ...]: ...
@overload
def vjp(
    func: Callable[[Tensor], Tensor],
    xs: Tensor,
    v: TensorOrTensors | None = None,
) -> tuple[Tensor, Tensor]: ...
@overload
def vjp(
    func: Callable[[Unpack[tuple[Tensor, ...]]], tuple[Tensor, ...]],
    xs: Tensor,
    v: TensorOrTensors | None = None,
) -> tuple[tuple[Tensor, ...], Tensor]: ...
@overload
def vjp(
    func: Callable[[Tensor], Tensor],
    xs: Sequence[Tensor],
    v: TensorOrTensors | None = None,
) -> tuple[Tensor, tuple[Tensor, ...]]: ...
@overload
def vjp(
    func: Callable[[Unpack[tuple[Tensor, ...]]], tuple[Tensor, ...]],
    xs: Sequence[Tensor],
    v: TensorOrTensors | None = None,
) -> tuple[tuple[Tensor, ...], tuple[Tensor, ...]]: ...

            >>> import paddle
            >>> def func(x, y):
            ...     return paddle.matmul(x, y)
            ...
            >>> x = paddle.to_tensor([[1., 2.], [3., 4.]])
            >>> J = paddle.incubate.autograd.Jacobian(func, [x, x])

def bar(a: ???) -> None:
    return
def t1(a:Tensor, b:Tensor) -> Tensor: # pass
    return Tensor()
def t2(a:Tensor) -> Tensor: # pass
    return Tensor()
def t3(a:Tensor, b:str) -> Tensor: # fail or pass
    return Tensor()
def t4(a:str)->Tensor: # fail
    return Tensor()
def t5(a:str)->str: # fail
    return '1'

_FuncOutT = TypeVar("_FuncOutT", Tensor, Sequence[Tensor])
_InputT = TypeVar("_InputT", Tensor, Sequence[Tensor])
def vjp(
    func: Callable[[Tensor], _FuncOutT],  # 这里需要 overload 一个 Sequence 的或者用 Protocol
    xs: _InputT,
    v: TensorOrTensors | None = None,
) -> tuple[_FuncOutT, _InputT]: ...

def func(a: ???) -> None:
    return
def t1(a:Tensor, b:Tensor) -> Tensor: # pass
    return Tensor()
def t2(a:Tensor) -> Tensor: # pass
    return Tensor()
func(t1)
func(t2)

_FuncInputT = ParamSpec("_InputT")
def func(a: Callable[_FuncInputT, _FuncOutT]) -> None: ...