Does plum dispatch tighter types priorer than looser types?

[roastduck]

Hi there,

I'm wondering wheter plum dispatch tighter types priorer than looser types? For example, when I have a dispatch with type A, and another with A | B, will A goes to A but B gose to A | B?

I tested some cases, some behaves like above, but not all the cases. The following int and bool case seems to make plum always choosing the same branch:

import plum

@plum.dispatch
def f(x: int):
    print("f(int)")

@plum.dispatch
def f(x: int | bool):
    print("f(int | bool)")

f(1)
f(True)

The example above prints

f(int | bool)
f(int | bool)

but I expect the output to be

f(int)
f(int | bool)

Even if there is a precedence, plum will still choose the second dispatch:

import plum

@plum.dispatch(precedence=1)
def g(x: int):
    print("g(int)")

@plum.dispatch(precedence=0)
def g(x: int | bool):
    print("g(int | bool)")

g(1)
g(True)

This outputs

g(int | bool)
g(int | bool)

Plum will choose the first dispatch only if the second dispatch does not exist:

import plum

@plum.dispatch
def h(x: int):
    print("h(int)")

h(1)

This outputs:

h(int)

So if there is a rule for the cases that one dispatch has a type that is a superset of the other dispatch's type?

Tested with plum-dispatch==2.5.7, beartype==0.21.0.

[wesselb]

Hey @roastduck!

What's going on is that booleans are considered integers, so the signature int | bool is equivalent to the signature int:

In [1]: from beartype.door import TypeHint, is_bearable

In [2]: is_bearable(True, int)
Out[2]: True

In [3]: TypeHint(int | bool) == TypeHint(int)
Out[3]: True

Therefore, in

import plum

@plum.dispatch
def f(x: int):
    print("f(int)")

@plum.dispatch
def f(x: int | bool):
    print("f(int | bool)")

the second definition overwrites the first.

You did, however, uncover a bug, because this overwriting is partly happening! The equality check for signatures currently isn't quite sound. I've opened a PR #216 to fix this.

[wesselb]

To clarify, this is the behaviour after #216:

import plum

@plum.dispatch
def f(x: int):
    print("f(int)")

print(f.methods)

@plum.dispatch
def f(x: int | bool):
    print("f(int | bool)")

print(f.methods)

@plum.dispatch
def f(x: int):
    print("f(int) (redef)")

print(f.methods)

Output:

List of 1 method(s):
    [0] f(x: int)
        <function f at 0x1084889d0> @ /<ipython-input-2-2d0a4603d4f3>:3

List of 1 method(s):
    [0] f(x: int | bool)
        <function f at 0x108489240> @ /<ipython-input-2-2d0a4603d4f3>:9

List of 1 method(s):
    [0] f(x: int)
        <function f at 0x10848a680> @ /<ipython-input-2-2d0a4603d4f3>:15