Article on Dispatch Decorator in Python

In Python, the @dispatch decorator is used to overload functions with different signatures. This is a common pattern in object-oriented programming where multiple methods can have the same name, but different parameters or argument types. The @dispatch decorator allows you to write a single function with multiple implementations that will be chosen at runtime based on the arguments passed to the function.

In Python, decorators are a powerful and widely used feature of the language. They allow you to modify or enhance the behaviour of functions, classes, or modules without changing their source code. One such decorator is the Dispatch Decorator, which enables dynamic dispatching of function calls based on the type of arguments passed to them.

What is Dispatch Decorator?

The Dispatch Decorator is a decorator that allows you to define a function that can be called with different arguments types, and then dynamically dispatches the call to the appropriate implementation based on the type of the arguments passed. The dispatching is done at runtime, based on the type of the arguments, and it allows you to define multiple implementations of the same function for different argument types.

Example

To implement the Dispatch Decorator in Python, you can use the functools module, which provides a decorator called singledispatch. The singledispatch decorator can be used to create a generic function that can dispatch its behavior based on the type of the first argument passed to it.

from functools import singledispatch
@singledispatch
def add(x, y):
   raise NotImplementedError("Unsupported type")
@add.register
def _(x: int, y: int) -> int:
   return x + y
@add.register
def _(x: str, y: str) -> str:
   return x + y

In the above example, we defined a generic function add that takes two arguments x and y. We then defined two implementations of the add function for the types int and str. We used the register method to register each implementation of the function with the add function. When we call the add function with two arguments of type int, it will call the implementation that accepts two integers and returns an integer. Similarly, when we call the add function with two arguments of type str, it will call the implementation that accepts two strings and returns a string.

Example

Here's an example of how to use the add function −

>>> add(1, 2)
3
>>> add("Hello, ", "world!")
"Hello, world!"

How does the @dispatch decorator work?

The @dispatch decorator is part of the multipledispatch library and is used to create multiple implementations of a single function. The decorator defines a dispatch mechanism that selects the implementation to use based on the number and types of arguments passed to the function.

Example

from multipledispatch import dispatch
@dispatch(int)
def square(x):
   return x * x
@dispatch(int, int)
def square(x, y):
   return x * y

In the above example, we've defined two implementations of the square() function, one that takes a single integer argument and returns its square, and another that takes two integer arguments and returns their product. The @dispatch decorator allows us to define these two implementations using the same function name.

When we call the square() function with a single argument, the first implementation will be called −

square(2)  # returns 4

When we call the square() function with two arguments, the second implementation will be called −

square(2, 3)  # returns 6

The @dispatch decorator allows us to create more concise and readable code by consolidating multiple functions with similar behavior into a single function.

Advanced usage of @dispatch decorator

The @dispatch decorator also supports more advanced usage patterns such as type promotion and type hierarchy. For example, we can define an implementation of the square() function that accepts a float argument, and the dispatch mechanism will automatically promote the float to an integer before calling the appropriate implementation −

@dispatch(float)
def square(x):
   return int(x) * int(x)

square(2.5)  # returns 4

We can also define an implementation of the square() function that accepts a subclass of integer and it will be automatically dispatched to the integer implementation −

class MyInt(int):
   pass
@dispatch(MyInt)
def square(x):
   return x * x
square(MyInt(2))  # returns 4

Conclusion

The @dispatch decorator is a powerful tool for creating multiple implementations of a single function in Python. It allows you to write more concise and readable code by consolidating multiple functions with similar behavior into a single function. With its support for type promotion and type hierarchy, the @dispatch decorator is a great way to write flexible and robust code that can handle a wide range of input types and formats.