class object typed with Type[SomeAbstractClass] should not complain about instantiation

[gvanrossum]

I wish this code would work:

from typing import Type

from abc import ABC, abstractmethod

class A(ABC):
  @abstractmethod
  def m(self) -> None: pass

def f(a: Type[A]) -> A:
    return a()  # E: Cannot instantiate abstract class 'A' with abstract attribute 'm'

The obvious intention is to pass f() a concrete subclass of A.

(UPDATE: My real-world use case is a bit more involved, in asyncio there are some classes that implement an elaborate ABC, and I'd like to just say SelectorEventLoop = ... # type: Type[AbstractEventLoop] rather than having to write out the class definition with all 38 concrete method definitions.)

[elazarg]

Wouldn't it be better to have Concrete[Type[A]] or something similar, so we can be somewhat safer?

[gvanrossum]

No, I don't think the little bit of extra safety is worth the cost of a new keyword and explaining the difference.

…

--Guido (mobile)

[gvanrossum]

Let's do this. We have such code in our codebase that would be flagged as an error except for another bug (#2430).

[elazarg]

What exactly should be done? What differentiates A() from T() from cls() ? It feels like we are making two different types, whether or not we choose to give them separate names. We want Type[T] to coerce/downcast into ConcreteType[T] which has the additional capability of being callable, but what are the rules for this coercion?

[gvanrossum]

Consider:

from typing import Type
from abc import abstractmethod

class A:
    @abstractmethod
    def m(self) -> None: pass

def f(cls: Type[A]) -> A:
    return cls()

def g() -> A:
    return A()

Currently both f() and g() have the same error:

error: Cannot instantiate abstract class 'A' with abstract attribute 'm'

I would want f() to be error-free but g() should still have the error.

[elazarg]

I understand the examples, but not the general rule. What should happen in the following?

class A:
    @abstractmethod
    def m(self) -> None: pass

A1 = A
A1()  # error?

[gvanrossum]

I don't really care what happens in that case. If it's considered an alias for A, it should be an error; if it's seen as a variable whose type is Type[A], then it should pass. Perhaps the implementation should just look whether it's represented as a def with is_type_obj() true or as a TypeType instance?