Expression has type "function", variable has type "Callable[[], None]"

[FFY00]

To Reproduce

from typing import Callable

class Test:
    def method1(self) -> None:
        pass

    def method2(self, optional: int = 0) -> None:
        pass

    def test(self, something: bool) -> None:
        action: Callable[[], None]
        action = self.method1 if something else self.method2

Expected Behavior

I believe the code above should validate in mypy.

Actual Behavior

$ mypy example.py
example.py:12: error: Incompatible types in assignment (expression has type "function", variable has type "Callable[[], None]")
Found 1 error in 1 file (checked 1 source file)

Your Environment

• Mypy version used: 0.910
• Mypy command-line flags: none
• Mypy configuration options from mypy.ini (and other config files): none
• Python version used: 3.9.5
• Operating system and version: Arch Linux

[isaacwritescode7]

This seems to be expected behavior, if the boolean something is false you reassign action to method2 which has an argument however in your code this creates a conflict because when you first typed action you said that it will never have any arguments but now it does, creating incompatible types in the assignment. To make mypy happy I presume that you will have to use a union. (Disclaimer: I am new to mypy so this may very well be incorrect)

from typing import Callable
from typing import Union


class Test:
    def method1(self) -> None:
        pass

    def method2(self, optional: int = 0) -> None:
        pass

    def test(self, something: bool) -> None:
        action: Union[Callable[[], None], Callable[[int], None]]
        action = self.method1 if something else self.method2

[erictraut]

This looks like a mypy bug to me. It type checks fine with pyright.

To work around the bug, you can do the following:

    def test(self, something: bool) -> None:
        action1: Callable[[], None] = self.method1
        action2: Callable[[], None] = self.method2
        action: Callable[[], None] = action1 if something else action2

[hauntsaninja]

Yeah, I think there are two improvements here. One, mypy uses joins for ternary expressions (#9264 and #5392 are related) where maybe a union / meet would be better. Two, the join logic doesn't take into account optional parameters, so you get builtins.function where maybe something sophisticated could come up with Callable[[], None].

[mdczaplicki]

Any update here?

[KotlinIsland]

The inverse of this situation (#17017) is when the callables are actually incompatible and are joined into function instead of object:

from typing import Callable

class C:
    def __init__(self, i: int=1): ...

c1: Callable[[], object] = C
c2: Callable[[int], object] = C
reveal_type(c1 if bool() else c2)  # Revealed type is "builtins.function"