Special case: Callable with one argument?

[eliegoudout]

Hello,

I noticed that in the case of a Callable with only one argument, my Python interpreter handles the following wrong syntax perfectly:

>>> Callable[int, str]
typing.Callable[[int], str]

which I find great for readability.

Is this a documented behaviour? Because for example, Mypy doesn't accept this syntax, as per its specification. I went through several PEPs mentionning Callable and I couldn't find any reference to this. I could only find following usages:

Callable[[...], ...]
Callable[[Concatenate[..., ...], ...]
Callable[ParamSpec, ...]

If it is in fact not documented yet, is it planned to be? Maybe it cannot because of conflicts of some type with ParamSpec? I'm not at all an expert at typing so I wouldn't know.

Thanks for enlightening me :)

[JelleZijlstra]

I believe runtime support for this syntax is accidental. The implementation of Callable is highly complex (in order to support ParamSpec, substitution, etc.).

I don't think type checkers should support this syntax. It's better that there's only one syntax so the overall language feels more consistent. In other cases where the first type argument to Callable doesn't require brackets (..., Concatenate, and ParamSpec), the first argument stands for the entire parameter list, representing possibly multiple parameters.

[eliegoudout]

I believe runtime support for this syntax is accidental.

Ok, good to know!

I don't think type checkers should support this syntax. It's better that there's only one syntax so the overall language feels more consistent. In other cases where the first type argument to Callable doesn't require brackets (..., Concatenate, and ParamSpec`), the first argument stands for the entire parameter list, representing possibly multiple parameters.

I get your point. I still think it's a shame that we can't enjoy simpler syntax than Callable[[int], str] :(

In the spirit of not making it a special case, Steven Stroxler proposed (PEP677) (int) -> str, which was rejected, but I still think something like

Callable[int -> str]
Callable[int, int -> str]
...

would be cool, and even easier to read.