I'm sure that there are other use cases for this, but the main one that comes to mind is inferring the type of function parameters. It is common that you want to override a superclass method, for example, which may accept many parameters that you don't need in the override:

class MyClass(BaseClass):
    def my_method(self, *args, **kwargs):
        ...
        return super().my_method(*args, **kwargs)

Unfortunately, most libraries, even if they provide type stubs, do not provide a TypedDict subclass that you can simply import in order to use Unpack[MyMethodKwargs], so the only way to not lose typing information is to redeclare all of the parameters.

If we could infer a ParamSpec type from the method type, and if we could infer the method type from the method object, then we could do something like:

class MyClass(BaseClass):
    def my_method(
        self,
        *args: Params[type[BaseClass.my_method]].args,
        **kwargs: Params[type[BaseClass.my_method]].kwargs,
    ):
        ...
        return super().my_method(*args, **kwargs)

I think that Python badly needs this, as **kwargs is so ubiquitous and one of the most notable places where type information is lost in my experience.

The way that TypeScript implements this is by leveraging pattern matching within conditional types:

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

This would be a very cool feature as it could be used for many other patterns, enabling things like Params[T], ReturnType[T], KeyOf[T], ValueOf[T], etc.

Unfortunately, since expressions were not implemented for structural pattern matching, we can't directly mirror the syntax, but it could maybe look something like:

type Params[C: Callable[..., Any]] = match C: P if case Callable[P, Any] else Never

or:

type Params[C: Callable[..., Any]] match C:
    case Callable[P, Any]: P
    case _: Never