Multimethod

2.0.2 · active · verified Thu Apr 09

Multimethod provides a decorator for adding multiple argument dispatching to functions in Python. It aims for simplicity and speed, utilizing type annotations to create a multimethod object that registers functions based on argument types. The library supports various type hints and advanced dispatching rules. It is currently at version 2.0.2 and has an active development and release cadence, with several releases per year.

Warnings

breaking Version 2.0 removed the `overload` decorator and the mechanism for resolving ambiguity using positional distance. Code relying on these features will break.
Fix: Migrate from `overload` to `@multimethod` with `isa` checks if predicate dispatching is needed, or adjust code that relied on positional distance for ambiguity resolution.
gotcha Keyword-only parameters are supported for type annotation, but `multimethod` (the main decorator) itself dispatches solely on positional arguments. Keyword arguments are ignored during the dispatching process. If keyword dispatch is needed, consider `multidispatch`.
Fix: Ensure that the order and types of positional arguments are sufficient for dispatching. If keyword dispatch is critical, `multidispatch` might be an alternative within the library or external solutions.
gotcha Typing aliases (e.g., `typing.List`, `typing.Dict`) do not consistently support the `issubclass` relation, which `multimethod` uses for type resolution. This can lead to unexpected dispatch behavior.
Fix: It is recommended to use Abstract Base Classes (ABCs) from `collections.abc` (e.g., `list` instead of `typing.List`, or `collections.abc.Sequence` for more abstract types) or direct concrete types for more reliable dispatching.
breaking Starting with version 2.0.0, `multimethod` requires Python 3.10 or newer. Older versions (e.g., 1.x) supported Python 3.6 or 3.7 and up.
Fix: Upgrade your Python environment to 3.10 or higher, or pin your `multimethod` dependency to a version compatible with your Python interpreter (e.g., `multimethod<2.0`).

Install

pip install multimethod Install stable version

Imports

multimethod
```
from multimethod import multimethod
```
The primary decorator for defining multimethods.
multimeta
```
from multimethod import multimeta
```
Metaclass for automatically converting class methods to multimethods.
multidispatch
```
from multimethod import multidispatch
```
Provides compatibility with the functools.singledispatch style, supporting keyword arguments for dispatching in this specific variant.

Quickstart

This example demonstrates how to define a function `func` with multiple implementations that are dispatched based on the runtime types of its arguments. The `@multimethod` decorator is applied to each implementation.

from multimethod import multimethod

@multimethod
def func(x: int, y: float):
    return f"Int and Float: {x} + {y}"

@multimethod
def func(x: float, y: int):
    return f"Float and Int: {x} + {y}"

@multimethod
def func(x: str, y: str):
    return f"Strings: {x} {y}"

print(func(1, 2.0))
print(func(3.0, 4))
print(func("Hello", "World"))

view raw JSON →