Correct typing for a global variable for a dictionary of functions

[rayzchen]

Let's say I have the types Foo, Bar and Baz defined somewhere, all inheriting from BaseClass. How would I typehint table in:

class BaseClass: pass
class Foo(BaseClass): pass
class Bar(BaseClass): pass
class Baz(BaseClass): pass

def doFoo(x: Foo) -> None: return None
def doBar(x: Bar) -> None: return None
def doBaz(x: Baz) -> None: return None

table = {
    Foo: doFoo,
    Bar: doBar,
    Baz: doBaz
}

I have tried

T = TypeVar("T", bound=BaseClass)
table: Dict[Type[T], Callable[[T], None]]

but mypy says Type variable T is unbound.

Full error:

test.py:13: error: Type variable "test.T" is unbound
test.py:13: note: (Hint: Use "Generic[T]" or "Protocol[T]" base class to bind "T" inside a class)
test.py:13: note: (Hint: Use "T" in function signature to bind "T" inside a function)
test.py:14: error: Dict entry 0 has incompatible type "Type[Foo]": "Callable[[Foo], None]"; expected "Type[T?]": "Callable[[T], None]"
test.py:15: error: Dict entry 1 has incompatible type "Type[Bar]": "Callable[[Bar], None]"; expected "Type[T?]": "Callable[[T], None]"
test.py:16: error: Dict entry 2 has incompatible type "Type[Baz]": "Callable[[Baz], None]"; expected "Type[T?]": "Callable[[T], None]"

[gandhis1]

That looks like you are attempting to do a higher-kinded type, which isn't possible in the type system currently. See #548

I think the best you can do is Dict[Type[BaseClass], Callable[[BaseClass], None]], which should be good enough, no? Invariance vs covariance strikes again

[rayzchen]

I get

test.py:13: error: Dict entry 0 has incompatible type "Type[Foo]": "Callable[[Foo], None]"; expected "Type[BaseClass]": "Callable[[BaseClass], None]"
test.py:14: error: Dict entry 1 has incompatible type "Type[Bar]": "Callable[[Bar], None]"; expected "Type[BaseClass]": "Callable[[BaseClass], None]"
test.py:15: error: Dict entry 2 has incompatible type "Type[Baz]": "Callable[[Baz], None]"; expected "Type[BaseClass]": "Callable[[BaseClass], None]"

[gandhis1]

Argh, this is because dict is invariant. Mapping is also not covariant in the key type which precludes that as the solution: #445

Thinking a bit more about this...