Multimethod provides a decorator for adding multiple argument dispatching to functions. The decorator creates a multimethod object as needed, and registers the function with its annotations.
There are several multiple dispatch libraries on PyPI. This one aims for simplicity and speed. With caching of argument types, it should be the fastest pure Python implementation possible.
from multimethod import multimethod @multimethod def func(x: int, y: float): ...
func is now a
multimethod which will delegate to the above function,
when called with arguments of the specified types.
Subsequent usage will register new types and functions to the existing multimethod of the same name.
@multimethod def func(x: float, y: int): ...
Alternatively, functions can be explicitly registered in the same style as functools.singledispatch. This syntax is also compatible with mypy, which by default checks that each name is defined once.
@func.register def _(x: bool, y: bool): ... @func.register(object, bool) @func.register(bool, object) def _(x, y): # stackable without annotations ...
Multimethods are implemented as mappings from signatures to functions, and can be introspected as such.
method[type, ...] # get registered function method[type, ...] = func # register function by explicit types
Multimethods support any types that satisfy the
including abstract base classes in
Subscripted generics are provisionally supported:
Mapping[...]- the first key-value pair is checked
Tuple[...]- all args are checked
Iterable[...]- the first arg is checked
Naturally checking subscripts is slower, but the implementation is optimized, cached, and bypassed if no subscripts are in use in the multimethod.
Dispatch resolution details:
If an exact match isn’t registered, the next closest method is called (and cached).
issubclassrelation is ambiguous, mro position is used as a tie-breaker.
If there are still ambiguous methods - or none - a custom
**kwargsmay be used when calling, but won’t affect the dispatching.
A skipped annotation is equivalent to
: object, which implicitly supports methods by leaving
If no types are specified, it will inherently match all arguments.
Overloads dispatch on annotated predicates. Each predicate is checked in the reverse order of registration.
The implementation is separate from
multimethod due to the different performance characteristics.
Instead a simple
isa predicate is provided for checking instance type.
from multimethod import isa, overload @overload def func(obj: isa(str)): ... @overload def func(obj: str.isalnum): ... @overload def func(obj: str.isdigit): ...
metaclass=multimeta to create a class with a special namespace which converts callables to multimethods, and registers duplicate callables with the original.
from multimethod import multimeta class Foo(metaclass=multimeta): def bar(self, x: str): ... def bar(self, x: int): ...
from multimethod import multimethod class Foo: @multimethod def bar(self, x: str): ... @bar.register def bar(self, x: int): ...
% pip install multimethod
100% branch coverage.
% pytest [--cov]
Python >=3.6 required
Expanded support for subscripted type hints
Python 3 required
Support for subscripted ABCs
Support for typing generics
Stricter dispatching consistent with singledispatch
Fix for Python 2 typing backport
Metaclass for automatic multimethods
Missing annotations default to object
Removed deprecated dispatch stacking
Forward references allowed in type hints
Overloads with predicate dispatch
Multimethods can be defined inside a class
Dispatch on Python 3 annotations