overload 1.0

Simple overloading of 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 signature')
TypeError: invalid call signature

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)