Right now if I remove these lines:

```python
    if parameters == ():
        raise TypeError("Cannot take a Concatenate of no types.")
    if not isinstance(parameters, tuple):
        parameters = (parameters,)
    if not isinstance(parameters[-1], ParamSpec):
        raise TypeError("The last parameter to Concatenate should be a "
                        "ParamSpec variable.")
```

from here: https://github.com/python/cpython/blob/09087b8519316608b85131ee7455b664c00c38d2/Lib/typing.py#L601-L607

And run the test suite - it passes.

To increase coverage I plan to:
1. Add a test for empty `Concatenate[]`
2. Add a test case when `ParamSpec` is not the last item of `Concatenate`
3. When passed parameter to `Concatenate` is not `tuple`

PR is on its way :)

Arguably the runtime should not check for incorrect calls to Concatenate. That's the job of static type checkers. So maybe that code could just be removed? (We don't bother checking things like list[0] either.)

> So maybe that code could just be removed?

I see this trend in typing.py :)

I think it makes sense to make all new types (I still consider `ParamSpec` and `Concatenate` as new, desipte the fact they are already released in 3.10) as flexible as possible.

I will change my PR.

With this change `typing.py` and `typing_extensions.py` will have different logic: https://github.com/python/typing/blob/523cf0233edc7a29502fbd30dc6bf641a7408e16/typing_extensions/src/typing_extensions.py#L1805-L1811 

Jelle, what should we do?

Let's change typing_extensions.py too in the same way.

Speaking of typing-extensions, it'd be great if someone could review https://github.com/python/typing/pull/963 :)

PR is updated, now `Concatenate` does not raise any semantic errors: https://github.com/python/cpython/pull/30619

I'm a little conflicted on this specific use case (but maybe I'm biased because I wrote the checks :).

I'm a strong proponent of less runtime checks. However, in this case, the exceptions serve as easy hints to the user, and they're meant to catch the most basic of errors. At the same time they barely add any overhead to our code.

Also, the last check may be required so that we can easily support subscripts (due to runtime quirks). I vaguely remember Serhiy mentioning that the semantics for subscripting a Callable[Concatenate[...], ...] is undefined by PEP 612. We were planning to formalize/reject the behavior, but I dropped the ball on that due to a lack of time. If that materializes, we're gonna raise an unclear runtime error about not enough typevars at subscript time anyways, so we might as well clearly tell the user at the start to prevent confusion.

"When in doubt, the status quo wins."

Maybe we should just close this and the PR without merging.

I think that in case when we preserve the runtime checks, they should be covered by tests. Right now - they are not.

So, I will switch my PR to the initial version with a new test case.

Does this sound right? :)

No, that would make the behavior normative.

Let sleeping dogs lie.