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.

Usage

There are a few options which trade-off dispatch speed for flexibility.

Decorator	Speed	Dispatch	Arguments
multimethod	fastest	cached lookup	positional only
multidispatch	-	binds to first signature + cached lookup	+ keywords
overload	slowest	checks all signatures serially	+ keywords & predicates

multimethod

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 issubclass relation, including abstract base classes in collections.abc and typing. Subscripted generics are supported:

• Union[...] or ... | ...
• Mapping[...] - the first key-value pair is checked
• tuple[...] - all args are checked
• Iterable[...] - the first arg is checked
• Type[...]
• Literal[...]
• Callable[[...], ...] - parameter types are contravariant, return type is covariant

Naturally checking subscripts is slower, but the implementation is optimized, cached, and bypassed if no subscripts are in use in the parameter. Empty iterables match any subscript, but don't special-case how the types are normally resolved.

Dispatch resolution details:

• If an exact match isn't registered, the next closest method is called (and cached).
• If the issubclass relation is ambiguous, mro position is used as a tie-breaker.
• If there are still ambiguous methods - or none - a custom TypeError is raised.
• Default and keyword-only parameters may be annotated, but won't affect dispatching.
• A skipped annotation is equivalent to : object.
• If no types are specified, it will inherently match all arguments.

classmethod and staticmethod may be used with a multimethod, but must be applied last, i.e., wrapping the final multimethod definition. For class and instance methods, cls and self participate in the dispatch as usual. They may be left blank when using annotations, otherwise use object as a placeholder.

class Foo:
    @multimethod
    def bar(cls, x: str):
        ...

    @classmethod # <- only put this @classmethod here on the final definition
    @bar.register
    def _(cls, x: int):
        ...

multidispatch

multidispatch is a wrapper to provide compatibility with functools.singledispatch. It requires a base implementation and use of the register method instead of namespace lookup. It also supports dispatching on keyword arguments.

overload

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. If an annotation is a type instead of a predicate, it will be converted into an isinstance check. Provisionally supports generics as well.

from multimethod import overload

@overload
def func(obj: str):
    ...

@overload
def func(obj: str.isalnum):
    ...

@overload
def func(obj: str.isdigit):
    ...

multimeta

Use 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):
        ...

Equivalent to:

from multimethod import multimethod

class Foo:
    @multimethod
    def bar(self, x: str):
        ...
        
    @bar.register
    def bar(self, x: int):
        ...

Installation

% pip install multimethod

Tests

100% branch coverage.

% pytest [--cov]

Changes

dev

• Python >=3.8 required
• Type[...] dispatches on class arguments
• | syntax for union types

1.9.1

• Dispatch is thread-safe

1.9

• Python 3.11 supported
• Fixes for Callable and object annotations

1.8

• Callable checks parameters and return type
• Support for NewType

1.7

• overload allows types and converts them to an isa check
• Only functions with docstrings combine signatures
• Fixes for subscripted union and literal checks

1.6

• Python >=3.7 required
• Improved checking for TypeErrors
• multidispatch has provisional support for dispatching on keyword arguments
• multidispatch supports static analysis of return type
• Fix for forward references and subscripts
• Checking type subscripts is done minimally based on each parameter
• Provisionally dispatch on Literal type
• Provisionally empty iterables match subscript

1.5

• Postponed evaluation of nested annotations
• Variable-length tuples of homogeneous type
• Ignore default and keyword-only parameters
• Resolved ambiguous Union types
• Fixed an issue with name collision when defining a multimethod
• Resolved dispatch errors when annotating parameters with meta-types such as type

1.4

• Python >=3.6 required
• Expanded support for subscripted type hints

1.3

• Python 3 required
• Support for subscripted ABCs

1.2

• Support for typing generics
• Stricter dispatching consistent with singledispatch

1.1

• Fix for Python 2 typing backport
• Metaclass for automatic multimethods

1.0

• Missing annotations default to object
• Removed deprecated dispatch stacking

0.7

• Forward references allowed in type hints
• Register method
• Overloads with predicate dispatch

0.6

• Multimethods can be defined inside a class

0.5

• Optimized dispatching
• Support for functools.singledispatch syntax

0.4

• Dispatch on Python 3 annotations