Function that returns certain types depending of the value of a parameter

[adrien-lsh]

Hello,

I have a question about the overloading of functions. I have a function that returns different things depending of the value of a parameter.
But I don't really know how to type-hint this to avoid pyright saying its the wrong type when I perfectly know it is not.
A small example:

from typing import Literal, overload


@overload
def foo(return_type: Literal['dict'] = ...) -> dict: ...
@overload
def foo(return_type: Literal['list'] = ...) -> list: ...


def foo(return_type: Literal['dict', 'list'] = 'list') -> dict | list:
    if return_type == 'dict':
        return {}
    else:
        return []

So, with this code, I have an error saying the overload overlaps with an incompatible type. I get that the type is not compatible, but I do not get why it it saying that Literal['dict'] is compatible with Literal['list']...

Maybe this is the wrong approach and I shouldn't overload by values, but I've done a lot of research and I can't find anything that could fit.

I really hope someone can help me on this matter. Thanks !

[erictraut]

The issue here is that both of your overloads have a default argument for the return_type parameter. That means foo() (with no arguments) applies to both of them. To eliminate the overlapping overload and make the overloads match the implementation, you should delete the = ... from the first overload.

[adrien-lsh]

It does yeah, I thought having the argument to be mandatory would be inconsistent with the implementation, but I get it now thanks !
Another question tho (sry): why does pyright doesnt complain when having unpacked arguments before ? (thats more like the implementation on some of the functions I'm trying to type hint in my project)

from typing import Literal, overload


@overload
def foo(*args, return_type: Literal['dict'] = ...) -> dict: ...
@overload
def foo(*args, return_type: Literal['list'] = ...) -> list: ...


def foo(*args, return_type: Literal['dict', 'list'] = 'list') -> dict | list:
    if return_type == 'dict':
        return {}
    else:
        return []

That's why I was surprised at first seeing this error, because I had two functions to type like that using overloads, and when I did the same thing to the third one (which doesn't have *args) it raised an error.

[erictraut]

I'm not sure what you mean by "unpacked arguments before ?". Can you elaborate? When you say "unpacked arguments", are you talking about a call expression that uses an unpack operator (*) for one or more of its argument expression? Or are you talking about an *args parameter followed by one or more keyword parameters within a function signature? That's permitted in python, so it's not an error condition.

[adrien-lsh]

Yeah I'm talking about the *args parameter, when I have it before the return_type parameter, and the overloads both have a default = ... it does not raise an error.
And I don't understand the difference that makes it raise an error without the *args parameter, and no errors with it.

[erictraut]

Ah, I see what you mean. Yeah, that should result in an overlapping overload error as well. I filed a bug report to track this.

[adrien-lsh]

Oh nice thank you ! So I'll just remove the default for the overloads of the *args functions and it should be good !