Simple overloading of methods and functions through an @overload decorator.

This module allows one to provide multiple interfaces for a functions, methods, classmethods, staticmethods or classes. See below for some notes about overloading classes, you strange person you.

The appropriate implementation is chosen based on the calling argument pattern.

For example:

>>> class A(object):
...   @overload
...   def method(self, a):
...     return 'a'
...   @method.add
...   def method(self, a, b):
...     return 'a, b'
...
>>> a = A()
>>> a.method(1)
'a'
>>> a.method(1, 2)
'a, b'

The overloading handles fixed, keyword, variable (*args) and arbitrary keyword (**keywords) arguments.

It also handles annotations if those annotations are types:

>>> @overload
... def func(a:int):
...   return 'int'
...
>>> @func.add
... def func(a:str):
...   return 'str'
...
>>> func(1)
'int'
>>> func('s')
'str'
>>> func(1.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "overload.py", line 94, in f
    raise TypeError('invalid call argument(s)')
TypeError: invalid call argument(s)

This feature (and currently the module in general) requires Python 3.

The docstring and name (ie. documentation) of the resultant callable will match that of the first callable overloaded.

@overload
class A(object):
    def __new__(cls):
        # this will fail because "A" is a function now
        return super(A, cls).__new__(cls)

@overload
class A(object):
    def __new__(cls):
        # must explicitly reference the base class
        return object.__new__(cls)