The structural type of typing.Callable

[superbobry]

Hi everyone,

It seems a bit unclear what typing.Callable is from the structural perspective. PEP-484 introduced it as a special-form and an alias of collections.abc.Callable, which has a __call__ method. However, neither mypy nor pyright seem to allow looking up __call__ on a value of callable type

from typing import Callable

def f(fn: Callable[[], int]):
    reveal_type(fn.__call__)

mypy

error: "Callable[[], int]" not callable  [operator]
note: Revealed type is "Any"

pyright

information: Type of "fn.__call__" is "Any"

Should we clarify the expected behavior?

[erictraut]

Before we discuss potential solutions, it would be good to understand what problem you're trying to solve. Why do you want to access the __call__ attribute of a Callable, and how do you intend to use the value of the __call__ attribute?

I'm not aware of this ever coming up before in typing forums, so I think you're doing something quite unusual here.

As you mentioned, Callable is a special form, and special forms often do not act like standard classes.

[superbobry]

Thanks Eric. I don't have an immediate use-case in mind. My goal here is just to better understand what typing.Callable is and to clarify what it means for typing.Callable to be an alias of collections.abc.Callable (as per PEP-484 and PEP-585).

[kmillikin]

Also, PEP 544 has "Callback protocols and Callable[...] types can be used interchangeably." One simple and direct way to explain what this means when substituting a Callable type where a callback protocol type is expected is to say what the signature of __call__ is for the Callable.

[superbobry]

I wanted to revisit this, because it is also unclear whether Callable has __qualname__.

mypy, pyright and pytype all pass the following snippet, but it fails at runtime:

from collections.abc import Callable
def f(g: Callable[..., None]) -> str:
  return g.__qualname__


class A:
  def __call__(self) -> None:
    ...

f(A())

[srittau]

I'm not sure why type checkers don't report an error here. While functions and lambdas have a __qualname__ (always, I think), the same is obviously not generally true for callable instances. As @Gobot1234 points out, it might make sense to have separate types/a separate type for functions/methods/lambdas.

Edit: As far as I can see, the typing spec is silent about this.

[Gobot1234]

This is why I wanted to make types.FunctionType subscriptable because I do agree the current behaviour is very undesirable and Callable not being a structural type with just dunder call is very strange