Support plum-like inheritance dispatch.

[coady]

Plum's comparison with multimethod cites this example:

from multimethod import multimethod


class A:
    def f(self, x):
        return "fallback"
        

class B(A):
    @multimethod
    def f(self, x: int):
        return x

>>> b = B()

>>> b.f(1)
1

>>> b.f("1")
DispatchError: ('f: 0 methods found', (<class '__main__.B'>, <class 'str'>), [])

A normal method dispatches based on its presence, not on its arguments. So to me this is ambiguous, and a reason to use multimethod functions instead of methods. The ambiguity comes from whether one pictures the dispatch occurring "twice", once on self and then again on all the args.

But it could be trivially supported, and backwards-compatible (assuming no one was relying on the dispatch error). So opening it up for discussion.

[coady]

Should also add there is a current solution: explicitly register the methods.

class A:
    def f(self, x):
        return "fallback"
        

class B(A):
    f = multimethod(A.f)

    @multimethod
    def f(self, x: int):
        return x

[snwnde]

The current solution appears good to me. This even works when the user has no control on the parent class A (see #75 (comment)).

What is more challenging is when dealing with classmethods. How could one apply last classmethod (or staticmethod) when f is already a classmethod in the parent class?

[coady]

class A:
    @classmethod
    def f(cls, x):
        return "fallback"
        

class B(A):
    f = multimethod(A.f.__func__)

    @classmethod
    @multimethod
    def f(cls, x: int):
        return x