Overlapping overloads with default arguments?

[Sahil Jain (whoami730)]

I have the below source code :

from typing import overload, Literal

@overload
def func(param: Literal[True] = ...) -> str : ...

@overload
def func(param: Literal[False] = ...) -> float : ...

def func(param: bool = False) -> str | float :
    if param:
        return str('plot_points')
    else:
        return float(1e-8)

It seems to error with Overload 1 for "func" overlaps overload 2 and returns an incompatible type (reportOverlappingOverload) , however it seems to pass with mypy without any errors.

I was expecting this to work after updates to the typing spec.
The above one can however be fixed by removing the additional = ... after Literal[X] types.

Another related example is -

from typing import overload, Literal

@overload
def func(param2: float = ..., param: Literal[True] = ...) -> str : ...

@overload
def func(param2: float = ..., param: Literal[False] = ...) -> float : ...

def func(param2: float = 1e-8, param: bool = False) :
    if param:
        return str('plot_points')
    else:
        return float(param2)

for which unfortunately we can't remove the = ... due to non-default arguments not following default arguments (pyright does not report this error after the removal though). And therefore I have no solution in mind to avoid the errors.

[Eric Traut (erictraut)]

This is an unsound overlapping overload. Mypy does not detect all unsound overlapping overloads.

You can fix the first example by eliminating the default argument in the Literal[True] case (the first overload) and leaving it in the second case. The implementation does not support a default argument of True, so that modification better reflects the implementation anyway.

The second example requires a bit more creativity to avoid the unsoundness:

@overload
def func(param2: float, param: Literal[True]) -> str: ...

@overload
def func(*, param2: float = ..., param: Literal[False] = False) -> float: ...

@overload
def func(param2: float = ..., param: Literal[False] = ..., /) -> float: ...

If you're comfortable with the unsoundness, you can suppress the error by adding a # type: ignore or # pyright: ignore comment.

[Sahil Jain (whoami730)]

1. The above overloads still raise a problem with func(param=True) as seen here.
2. What does "unsound" overlapping overload mean? Why is it an overlapping overload in the first place? I would expect it to not be an overlapping overload because the function implementation uses bool and not Literal[X].
3. The solution for second example, even if partially incorrect as it stands, is an extremely complicated solution. If there are more arguments, it will get more and more complex potentially.

[傅立业（Chris Fu） (Azureblade3808)]

What does "unsound" overlapping overload mean? Why is it an overlapping overload in the first place? I would expect it to not be an overlapping overload because the function implementation uses bool and not Literal[X].

Because calling func() (without argument) applies to both overloads.

The solution for second example, even if partially incorrect as it stands, is an extremely complicated solution. If there are more arguments, it will get more and more complex potentially.

True. This is the exact reason why I turned off diagnosis for reportOverlappingOverload.

[Sahil Jain (whoami730)]

func() without arguments should inherently borrow the default arguments from the implementation and therefore be interpreted as func(param2 = 1e-8, param = False), should it not? I believe that is the expectation one has with default arguments.

[傅立业（Chris Fu） (Azureblade3808)]

No. For users, the signature of an overloaded function is built up with all its overloads, and its implementation part can be totally ignored. There is no such thing like "borrow".

[傅立业（Chris Fu） (Azureblade3808)]

For the second example --

# pyright: strict

from typing import overload, Literal

@overload
def func(*, param: Literal[True]) -> str: ...

@overload
def func(param2: float, param: Literal[True]) -> str : ...

@overload
def func(param2: float = ..., param: Literal[False] = ...) -> float : ...

def func(param2: float = 1e-8, param: bool = False) :
    if param:
        return str('plot_points')
    else:
        return float(param2)

reveal_type(func())  # float
reveal_type(func(0))  # float
reveal_type(func(param2=0))  # float
reveal_type(func(param=True))  # str
reveal_type(func(0, True))  # str
reveal_type(func(0, param=True))  # str
reveal_type(func(param2=0, param=True))  # str
reveal_type(func(param=False))  # float
reveal_type(func(0, False))  # float
reveal_type(func(0, param=False))  # float
reveal_type(func(param2=0, param=False))  # float
reveal_type(func(param=bool()))  # str | float
reveal_type(func(0, bool()))  # str | float
reveal_type(func(0, param=bool()))  # str | float
reveal_type(func(param2=0, param=bool()))  # str | float