Skip to main content

Multiple dispatch in function annotaions

Project description

Build Status

A relatively sane approach to multiple dispatch in Python.

Forked from to support and use annotations for dispatch. This implementation of multiple dispatch is efficient, mostly complete, performs static analysis to avoid conflicts, and provides optional namespace support. It looks good too.


>>> from adispatch import adispatch

>>> @adispatch()
... def add(x: int, y: int):
...     return x + y

>>> @adispatch()
... def add(x: object, y: object):
...     return "%s + %s" % (x, y)

>>> add(1, 2)

>>> add(1, 'hello')
'1 + hello'

What this does

  • Dispatches on all non-keyword arguments

  • Supports inheritance

  • Supports instance methods

  • Supports union types, e.g. (int, float)

  • Supports builtin abstract classes, e.g. Iterator, Number, ...

  • Caches for fast repeated lookup

  • Identifies possible ambiguities at function definition time

  • Provides hints to resolve ambiguities when they occur

  • Supports namespaces with optional keyword arguments

What this doesn’t do

  • Vararg dispatch

def add(*args: [int]):
  • Diagonal dispatch

a = arbitrary_type()
def are_same_type(x: a, y: a):
    return True

Installation and Dependencies

adispatch supports Python 3.2+, is pure python and requires no other dependencies.


New BSD. See License.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

adispatch-0.5.0.tar.gz (7.8 kB view hashes)

Uploaded Source

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page