This document discusses multiple dispatch or multimethods, which is a feature in some object-oriented programming languages that allows a function or method to be dynamically dispatched based on the runtime types of more than one of its arguments. It provides examples of languages that natively support multiple dispatch like Common Lisp and Clojure. It also discusses how multiple dispatch can be approximated in languages that only support single dispatch and describes libraries that extend other languages like Python and Java to add multiple dispatch capabilities.

2. •
•
•
•
•
•
•
•
Introduction
Understanding
Datatype and practical use
Dynamic dispatch study
Multiple dispatch examples
Pythons
Languages supporting dispatches
Multimethods in other languages via
extentions

3. •
•
•
•
•
Multiple dispatch or multimethods or function overloading is the feature
of object-oriented programming languages
which a function or method can be dynamically dispatched based on the
run time (dynamic) type of more than one of its arguments.
It is an extension of single dispatch polymorphism
In which method call is dynamically dispatched based on the actual
derived type of the object on which the method has been called.
Multiple dispatch generalizes the dynamic dispatching to work with a
combination of two or more objects.

4. When Several functions having same name in such cases,
the name at the function call site is not sufficient for
identifying the code to be executed .Here the dispatchment
arrises.
• single-dispatch OOP languages when invoking a method
(“function calling”) one of its arguments is treated specially
and used to determine which of the methods of that name is
to be called.
FOR EG:-special .method (other, arguments, here);

5. • By contrast, in languages with multiple dispatch, the
selected method is the one whose arguments match the
number and function call type.
• There is no "special" argument that "owns" the
function/method carried out in a particular call.
• Such as Common Lisp Object System (CLOS) is latest
example of multiple dispatch.

6. • programming languages that defer data type identification
until run-time,
• the selection among alternative functions must occur at
run-time, based on the dynamically determined types of
function arguments.
• Functions whose alternative implementations are selected
in this manner are referred to most generally as
multimethods.
• there is some run-time cost associated with dynamically
dispatching function call.

7. •
the distinction between overloading and multimethods can
be blurred,
• the compiler determining whether compile-time selection
can be applied to a given function call, or whether slower
run-time dispatch is needed.

8. •
•
•
•
•
dynamic dispatch in mostly compilers languages was studied and the
results stated that
13%-32% of generic functions utilize the dynamic type of a single
argument,
while 2.7%-6.5% of them utilize the dynamic type of multiple
arguments.
remaining 65%-93% of generic functions have a single concrete method
(overrider), and therefore are not considered to use the dynamic types
of their arguments.
In addition, the study reports that 2%-20% of generic functions had two
and 3%-6% had three concrete function implementations.

9. •
•
•
•
•
In the presence of multiple dispatch, the traditional idea of methods as
being defined in classes and contained in objects becomes less appealing
—
each collide-with method there is attached to two different classes, not
one.
Hence, the special syntax for method invocation generally disappears, so
that method invocation looks exactly like ordinary function invocation
methods are grouped not in classes but in generic functions.
AS IN multiple dispatch, such as Common Lisp, it

10. •
In languages that do not support multiple dispatch at the language definition or syntactic
level, it is often possible to add multiple dispatch using a library extension.
•
For example, the module multimethods.py provides CLOS-style multimethods for Python
without changing the underlying syntax or keywords of the language.
•
•
Multiple dispatch or multimethods or function overloading is the feature of some
object-oriented langages in which a function or method can be dynamically dispatched
based on the run time (dynamic) type of more than one of its arguments.
This is an extension of single dispatch polymorphism where a method call is dynamically
dispatched based on the actual derived type of the object on which the method has been
called. Multiple dispatch generalizes the dynamic dispatching to work with a combination
of two or more objects.

11. EXAMPLE OF MULTIPLE DISPATCH
•
•
•
•
•
C does not have dynamic dispatch, Often an enum is used to identify the
subtype of an object. Dynamic dispatch can be done by looking up this
value in a function pointer branch table.
EX:-typedef enum { asteroid = 0, spaceship } Thing;
C++ is being considered,[3] currently C++ only supports single dispatch
natively. The methods of working around this limitation are analogous;
either use the visitor pattern, double dispatch, dynamic cast:
it can be approximately implemented using double dispatch or a type
based lookup table as outlined in the C/C++
JAVA supports only single dispatch and code like visitor pattern helps
to solve this problem of its implementatiopn

12. •
•
•
•
•
•
•
•
•
•
•
•
•
•
PRogramming languages that support general multimethods:
Common Lisp (via the Common Lisp Object System)
Haskell via Multi-parameter type classes
Dylan
Nice
Cecil
R
Groovy
Perl 6
Seed7
Clojure
C# 4.0
Fortress
TADS

13. Multimethods in other languages via
extensions:
•
•
•
•
•
•
•
•
Scheme (via e.g. TinyCLOS)
Python (via PEAK-Rules, RuleDispatch, gnosis.magic.multimethods, or
PyMultimethods)
Perl (via the module Class::Multimethods)
Java (using the extension MultiJava)
Ruby (via the library The Multiple Dispatch Library and
Multimethod Package and Vlx-Multimethods Package)
.NET (via the library MultiMethods.NET)
C# (via the library multimethod-sharp)
Factor (via the standard multi-methods vocabulary)