Multiple dispatch ormultimethods is a feature of someprogramming languages in which afunction ormethod can bedynamically dispatched based on therun-time (dynamic) type or, in the more general case, some other attribute of more than one of itsarguments.^[1] This is a generalization ofsingle-dispatchpolymorphism where a function or method call is dynamically dispatched based on the derived type of the object on which the method has been called. Multiple dispatch routes the dynamic dispatch to the implementing function or method using the combined characteristics of one or more arguments.

Developers of computer software typically organizesource code into named blocks variously calledsubroutines, procedures, subprograms, functions, or methods. The code in the function is executed bycalling it – executing a piece of code that references itsname. This transfers control temporarily to the called function; when the function's execution has completed, control is typically transferred back to the instruction in thecaller that follows the reference.

Function names are usually selected so as to be descriptive of the function's purpose. It is sometimes desirable to give several functions the same name, often because they perform conceptually similar tasks, but operate on different types of input data. In such cases, the name reference at the function call site is not sufficient for identifying the block of code to be executed. Instead, the number and type of the arguments to the function call are also used to select among several function implementations.

In more conventional, i.e.,single-dispatchobject-oriented programming languages, when invoking a method (sending a message inSmalltalk,calling a member function inC++), one of its arguments is treated specially and used to determine which of the (potentially many) classes of methods of that name is to be applied. In many languages, thespecial argument is indicated syntactically; for example, a number of programming languages put the special argument before a dot in making a method call:special.method(other, arguments, here), so thatlion.sound() would produce a roar, whereassparrow.sound() would produce a chirp.

In contrast, in languages with multiple dispatch, the selected method is simply the one whose arguments match the number and type of the function call. There is nospecial argument thatowns the function/method carried out in a particular call.

Multiple dispatch should be distinguished fromfunction overloading, in which static typing information, such as a term's declared or inferred type (or base type in a language with subtyping) is used to determine which of several possibilities will be used at a given call site, and that determination is made at compile or link time (or some other time before program execution starts) and is thereafter invariant for a given deployment or run of the program. Many languages such as C++ offer robust function overloading but do not offer dynamic multiple dispatch (C++ only permits dynamic single dispatch through use of virtual functions).

When working with languages that can discriminatedata types atcompile time, selecting among the alternatives can occur then. The act of creating such alternative functions for compile time selection is usually referred to asoverloading a function.

In programming languages that defer data type identification until run time (i.e.,late binding), selection among alternative functions must occur then, based on the dynamically determined types of function arguments. Functions whose alternative implementations are selected in this manner are referred to most generally asmultimethods.

There is some run-time cost associated with dynamically dispatching function calls. In some languages,^{[citation needed]} the distinction between overloading and multimethods can be blurred, with the compiler determining whether compile time selection can be applied to a given function call, or whether slower run time dispatch is needed.

There are several known issues with dynamic-dispatch, both single and multiple. While many of these issues are solved for single-dispatch, which has been a standard feature in object-oriented programming languages for decades, these issues become more complicated in the multiple-dispatch case.

In most popular programming languages, source code is delivered and deployed in granules of functionality which we will here callpackages; actual terminology for this concept varies between language. Each package may contain multiple type, value, and function definitions, packages are often compiled separately in languages with a compilation step, and a non-cyclical dependency relationship may exist. A complete program is a set of packages, with amain package which may depend on several other packages, and the whole program consisting of the transitive closure of the dependency relationship.

The so-calledexpression problem relates to the ability for code in a depending package to extend behaviors (functions or datatypes) defined in a base package from within an including package, without modifying the source to the base package. Traditional single-dispatch OO languages make it trivial to add new datatypes but not new functions; traditional functional languages tend to have the opposite effect, and multiple dispatch, if implemented correctly, allows both. It is desirable for an implementation of multiple dispatch to have the following properties:

• It is possible to define different "cases" of a multi-method from within different packages without modifying the source of a base package.
• Inclusion of another package in the program should not change the behavior of a given multi-method call, when the call does not use any datatypes defined in the package.
• Conversely, if a datatype is defined in a given package, and a multi-method extension using that type is also defined in the same package, and a value of that type is passed (through a base type reference or into a generic function) into another package with no dependency on that package, and then the multi-method is invoked with that value as an argument, the multi-method case defined in the package which includes the type should be employed. To put it another way—within a given program, the same multi-method invoked with the same set of arguments should resolve to the same implementation, regardless of the location of the call site, and whether or not a given definition is "in scope" or "visible" at the point of the method call.

It is generally desirable that for any given invocation of a multi-method, there be at most one "best" candidate among implementation cases of the multi-method, and/or that if there is not, that this be resolved in a predictable and deterministic fashion, including failure. Non-deterministic behavior is undesirable. Assuming a set of types with a non-circular subtyping relationship, one can define that one implementation of a multi-method is "better" (more specific) if all dynamically-dispatched arguments in the first are subtypes of all dynamically-dispatched arguments specified in the second, and at least one is a strict subtype. With single dispatch and in the absence ofmultiple inheritance, this condition is trivially satisfied, but with multiple dispatch, it is possible for two or more candidates to satisfy a given actual argument list, but neither is more specific than the other (one dynamic argument being the subtype in one case, another being the subtype in the other case). This particularly can happen if two different packages, neither depending on the other, both extend some multi-method with implementations concerning each package's types, and then a third package that includes both (possibly indirectly) then invokes the multi-method using arguments from both packages.

Possible resolutions include:

• Treating any ambiguous calls as an error. This might be caught at compile time (or otherwise before deployment), but might not be detected until runtime and produce a runtime error.
• Ordering the arguments, so e.g. the case with the most specific first argument is selected, and subsequent arguments are not considered for ambiguity resolution unless the first argument is insufficient to resolve the issue.
• Construction of other rules for resolving an ambiguity in one direction or another. Sometimes, such rules might be arbitrary and surprising. In the rules for static overload resolution in C++, for instance, a type which matches exactly is understandably considered a better match than a type which matches through a base type reference or a generic (template) parameter. However, if the only possible matches are either through a base type or a generic parameter, the generic parameter is preferred over the base type, a rule that sometimes produces surprising behavior.

Efficient implementation of single-dispatch, including in programming languages that are separately compiled to object code and linked with a low-level (not-language-aware) linker, including dynamically at program load/start time or even under the direction of the application code, are well known. The "vtable" method developed in C++ and other early OO languages (where each class has an array of function pointers corresponding to that class's virtual functions) is nearly as fast as a static method call, requiring O(1) overhead and only one additional memory lookup even in the un-optimized case. However, the vtable method uses the function name and not the argument type as its lookup key, and does not scale to the multiple dispatch case. (It also depends on the object-oriented paradigm of methods being features of classes, not standalone entities independent of any particular datatype).

Efficient implementation of multiple-dispatch remains an ongoing research problem.

To estimate how often multiple dispatch is used in practice, Muschevici et al.^[2] studied programs that use dynamic dispatch. They analyzed nine applications, mostly compilers, written in six different languages:Common Lisp Object System,Dylan,Cecil, MultiJava, Diesel, and Nice. Their results show that 13–32% of generic functions use the dynamic type of one argument, while 2.7–6.5% of them use the dynamic type of multiple arguments. The remaining 65–93% of generic functions have one concrete method (overrider), and thus are not considered to use the dynamic types of their arguments. Further, the study reports that 2–20% of generic functions had two and 3–6% had three concrete function implementations. The numbers decrease rapidly for functions with more concrete overriders.

Multiple dispatch is used much more heavily inJulia, where multiple dispatch was a central design concept from the origin of the language: collecting the same statistics as Muschevici on the average number of methods per generic function, it was found that the Juliastandard library uses more than double the amount of overloading than in the other languages analyzed by Muschevici, and more than 10 times in the case ofbinary operators.^[3]

The data from these papers is summarized in the following table, where the dispatch ratioDR is the average number of methods per generic function; the choice ratioCR is the mean of the square of the number of methods (to better measure the frequency of functions with a large number of methods);^[2][3] and the degree of specializationDoS is the average number of type-specialized arguments per method (i.e., the number of arguments that are dispatched on):

The theory of multiple dispatching languages was first developed by Castagna et al., by defining a model for overloaded functions withlate binding.^[4][5] It yielded the first formalization of theproblem of covariance and contravariance of object-oriented languages^[6] and a solution to the problem of binary methods.^[7]

Distinguishing multiple and single dispatch may be made clearer by an example. Imagine a game that has, among its (user-visible) objects, spaceships and asteroids. When two objects collide, the program may need to do different things according to what has just hit what.

C# introduced support for dynamic multimethods in version 4^[8] (April 2010) using the 'dynamic' keyword. The following example demonstrates multimethods. Like many other statically-typed languages, C# also supports static method overloading.^[9] Microsoft expects that developers will choose static typing over dynamic typing in most scenarios.^[10] The 'dynamic' keyword supports interoperability with COM objects and dynamically-typed .NET languages.

The example below uses features introduced in C# 9 and C# 10.

usingstaticColliderLibrary;Console.WriteLine(Collide(newAsteroid(101),newSpaceship(300)));Console.WriteLine(Collide(newAsteroid(10),newSpaceship(10)));Console.WriteLine(Collide(newSpaceship(101),newSpaceship(10)));stringCollide(SpaceObjectx,SpaceObjecty)=>x.Size>100&&y.Size>100?"Big boom!":CollideWith(xasdynamic,yasdynamic);// Dynamic dispatch to CollideWith methodclassColliderLibrary{publicstaticstringCollideWith(Asteroidx,Asteroidy)=>"a/a";publicstaticstringCollideWith(Asteroidx,Spaceshipy)=>"a/s";publicstaticstringCollideWith(Spaceshipx,Asteroidy)=>"s/a";publicstaticstringCollideWith(Spaceshipx,Spaceshipy)=>"s/s";}abstractrecordSpaceObject(intSize);recordAsteroid(intSize):SpaceObject(Size);recordSpaceship(intSize):SpaceObject(Size);

Output:

Big boom!a/ss/s

Groovy is a general purposeJava compatible/interusableJVM language, which, contrary to Java, uses late binding / multiple dispatch.^[11]

/*    Groovy implementation of C# example above    Late binding works the same when using non-static methods or compiling class/methods statically    (@CompileStatic annotation)*/classProgram{staticvoidmain(String[]args){printlnCollider.collide(newAsteroid(101),newSpaceship(300))printlnCollider.collide(newAsteroid(10),newSpaceship(10))printlnCollider.collide(newSpaceship(101),newSpaceship(10))}}classCollider{staticStringcollide(SpaceObjectx,SpaceObjecty){(x.size>100&&y.size>100)?"big-boom":collideWith(x,y)// Dynamic dispatch to collideWith method}privatestaticStringcollideWith(Asteroidx,Asteroidy){"a/a"}privatestaticStringcollideWith(Asteroidx,Spaceshipy){"a/s"}privatestaticStringcollideWith(Spaceshipx,Asteroidy){"s/a"}privatestaticStringcollideWith(Spaceshipx,Spaceshipy){"s/s"}}classSpaceObject{intsizeSpaceObject(intsize){this.size=size}}@InheritConstructorsclassAsteroidextendsSpaceObject{}@InheritConstructorsclassSpaceshipextendsSpaceObject{}

In a language with multiple dispatch, such asCommon Lisp, it might look more like this (Common Lisp example shown):

(defmethodcollide-with((xasteroid)(yasteroid));; deal with asteroid hitting asteroid)(defmethodcollide-with((xasteroid)(yspaceship));; deal with asteroid hitting spaceship)(defmethodcollide-with((xspaceship)(yasteroid));; deal with spaceship hitting asteroid)(defmethodcollide-with((xspaceship)(yspaceship));; deal with spaceship hitting spaceship)

and similarly for the other methods. Explicit testing and "dynamic casting" are not used.

In the presence of multiple dispatch, the traditional idea of methods as being defined in classes and contained in objects becomes less appealing—eachcollide-with method above 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, and methods are grouped not in classes but ingeneric functions.

Julia has built-in multiple dispatch, and it is central to the language design.^[3] The Julia version of the example above might look like:

abstracttypeSpaceObjectendstructAsteroid<:SpaceObjectsize::IntendstructSpaceship<:SpaceObjectsize::Intendcollide_with(::Asteroid,::Spaceship)="a/s"collide_with(::Spaceship,::Asteroid)="s/a"collide_with(::Spaceship,::Spaceship)="s/s"collide_with(::Asteroid,::Asteroid)="a/a"collide(x::SpaceObject,y::SpaceObject)=(x.size>100&&y.size>100)?"Big boom!":collide_with(x,y)

Output:

julia>collide(Asteroid(101),Spaceship(300))"Big boom!"julia>collide(Asteroid(10),Spaceship(10))"a/s"julia>collide(Spaceship(101),Spaceship(10))"s/s"

Raku, like Perl, uses proven ideas from other languages, and type systems have shown themselves to offer compelling advantages in compiler-side code analysis and powerful user-side semantics via multiple dispatch.

It has both multimethods, and multisubs. Since most operators are subroutines, it also has multiple dispatched operators.

Along with the usual type constraints, it also haswhere constraints that allow making very specialized subroutines.

subsetMassofRealwhere0 ^..^Inf;roleStellar-Object {hasMass$.massisrequired;methodname ()returnsStr {...};}classAsteroiddoesStellar-Object {methodname () {'an asteroid' }}classSpaceshipdoesStellar-Object {hasStr$.name ='some unnamed spaceship';}myStr@destroyed = <obliterateddestroyedmangled >;myStr@damaged = « damaged'collided with''was damaged by' »;# We add multi candidates to the numeric comparison operators because we are comparing them numerically,# but makes no sense to have the objects coerce to a Numeric type.# ( If they did coerce we wouldn't necessarily need to add these operators. )# We could have also defined entirely new operators this same way.multisubinfix:« <=> » (Stellar-Object:D$a,Stellar-Object:D$b ) {$a.mass <=>$b.mass }multisubinfix:« < » (Stellar-Object:D$a,Stellar-Object:D$b ) {$a.mass <$b.mass }multisubinfix:« > » (Stellar-Object:D$a,Stellar-Object:D$b ) {$a.mass >$b.mass }multisubinfix:« == » (Stellar-Object:D$a,Stellar-Object:D$b ) {$a.mass ==$b.mass }# Define a new multi dispatcher, and add some type constraints to the parameters.# If we didn't define it we would have gotten a generic one that didn't have constraints.protosubcollide (Stellar-Object:D $,Stellar-Object:D $ ) {*}# No need to repeat the types here since they are the same as the prototype.# The 'where' constraint technically only applies to $b not the whole signature.# Note that the 'where' constraint uses the `<` operator candidate we added earlier.multisubcollide ($a,$bwhere$a <$b ) {say"$a.name() was @destroyed.pick() by $b.name()";}multisubcollide ($a,$bwhere$a >$b ) {# redispatch to the previous candidate with the arguments swappedsamewith$b,$a;}# This has to be after the first two because the other ones# have 'where' constraints, which get checked in the# order the subs were written. ( This one would always match. )multisubcollide ($a,$b ) {# randomize the ordermy ($n1,$n2) = ($a.name,$b.name ).pick(*);say"$n1 @damaged.pick() $n2";}# The following two candidates can be anywhere after the proto,# because they have more specialized types than the preceding three.# If the ships have unequal mass one of the first two candidates gets called instead.multisubcollide (Spaceship$a,Spaceship$bwhere$a ==$b ){my ($n1,$n2) = ($a.name,$b.name ).pick(*);say"$n1 collided with $n2, and both ships were ",    (@destroyed.pick,'left damaged' ).pick;}# You can unpack the attributes into variables within the signature.# You could even have a constraint on them `(:mass($a) where 10)`.multisubcollide (Asteroid $ (:mass($a)),Asteroid $ (:mass($b)) ){say"two asteroids collided and combined into one larger asteroid of mass { $a + $b }";}mySpaceship$Enterprise .=new(:mass(1),:name('The Enterprise'));collideAsteroid.new(:mass(.1)),$Enterprise;collide$Enterprise,Spaceship.new(:mass(.1));collide$Enterprise,Asteroid.new(:mass(1));collide$Enterprise,Spaceship.new(:mass(1));collideAsteroid.new(:mass(10)),Asteroid.new(:mass(5));

In languages that do not support multiple dispatch at the language definition or syntactic level, it is often possible to add multiple dispatch using alibrary extension. JavaScript and TypeScript do not support multimethods at the syntax level, but it is possible to add multiple dispatch via a library. For example, themultimethod package^[12] provides an implementation of multiple dispatch, generic functions.

Dynamically-typed version in #"ltr">

import{multi,method}from'@arrows/multimethod'classAsteroid{}classSpaceship{}constcollideWith=multi(method([Asteroid,Asteroid],(x,y)=>{// deal with asteroid hitting asteroid}),method([Asteroid,Spaceship],(x,y)=>{// deal with asteroid hitting spaceship}),method([Spaceship,Asteroid],(x,y)=>{// deal with spaceship hitting asteroid}),method([Spaceship,Spaceship],(x,y)=>{// deal with spaceship hitting spaceship}),)

import{multi,method,Multi}from'@arrows/multimethod'classAsteroid{}classSpaceship{}typeCollideWith=Multi&{(x:Asteroid,y:Asteroid):void(x:Asteroid,y:Spaceship):void(x:Spaceship,y:Asteroid):void(x:Spaceship,y:Spaceship):void}constcollideWith:CollideWith=multi(method([Asteroid,Asteroid],(x,y)=>{// deal with asteroid hitting asteroid}),method([Asteroid,Spaceship],(x,y)=>{// deal with asteroid hitting spaceship}),method([Spaceship,Asteroid],(x,y)=>{// deal with spaceship hitting asteroid}),method([Spaceship,Spaceship],(x,y)=>{// deal with spaceship hitting spaceship}),)

Python

frommultimethodsimportDispatchfromgame_objectsimportAsteroid,Spaceshipfromgame_behaviorsimportas_func,ss_func,sa_funccollide=Dispatch()collide.add_rule((Asteroid,Spaceship),as_func)collide.add_rule((Spaceship,Spaceship),ss_func)collide.add_rule((Spaceship,Asteroid),sa_func)defaa_func(a,b):"""Behavior when asteroid hits asteroid."""# ...define new behavior...collide.add_rule((Asteroid,Asteroid),aa_func)

# ...later...collide(thing1,thing2)

@multimethod(Asteroid,Asteroid)defcollide(a,b):"""Behavior when asteroid hits a asteroid."""# ...define new behavior...@multimethod(Asteroid,Spaceship)defcollide(a,b):"""Behavior when asteroid hits a spaceship."""# ...define new behavior...# ... define other multimethod rules ...

fromplumimportdispatch@dispatchdefcollide(a:Asteroid,b:Asteroid):"""Behavior when asteroid hits a asteroid."""# ...define new behavior...@dispatchdefcollide(a:Asteroid,b:Spaceship):"""Behavior when asteroid hits a spaceship."""# ...define new behavior...# ...define further rules...

Emulating multiple dispatch

C

typedefvoid(*CollisionCase)(void);voidcollision_AA(void){/* handle Asteroid-Asteroid collision  */};voidcollision_AS(void){/* handle Asteroid-Spaceship collision */};voidcollision_SA(void){/* handle Spaceship-Asteroid collision */};voidcollision_SS(void){/* handle Spaceship-Spaceship collision*/};typedefenum{THING_ASTEROID=0,THING_SPACESHIP,THING_COUNT/* not a type of thing itself, instead used to find number of things */}Thing;CollisionCasecollisionCases[THING_COUNT][THING_COUNT]={{&collision_AA,&collision_AS},{&collision_SA,&collision_SS}};voidcollide(Thinga,Thingb){(*collisionCases[a][b])();}intmain(void){collide(THING_SPACESHIP,THING_ASTEROID);}

#include<stdio.h>#include<cos/Object.h>#include<cos/gen/object.h>// classesdefclass(Asteroid)// data membersendclassdefclass(Spaceship)// data membersendclass// genericsdefgeneric(_Bool,collide_with,_1,_2);// multimethodsdefmethod(_Bool,collide_with,Asteroid,Asteroid)// deal with asteroid hitting asteroidendmethoddefmethod(_Bool,collide_with,Asteroid,Spaceship)// deal with asteroid hitting spaceshipendmethoddefmethod(_Bool,collide_with,Spaceship,Asteroid)// deal with spaceship hitting asteroidendmethoddefmethod(_Bool,collide_with,Spaceship,Spaceship)// deal with spaceship hitting spaceshipendmethod// example of useintmain(void){OBJa=gnew(Asteroid);OBJs=gnew(Spaceship);printf("<a,a> = %d\n",collide_with(a,a));printf("<a,s> = %d\n",collide_with(a,s));printf("<s,a> = %d\n",collide_with(s,a));printf("<s,s> = %d\n",collide_with(s,s));grelease(a);grelease(s);}

C++

// Example using run time type comparison via dynamic_caststructThing{virtualvoidcollideWith(Thing&other)=0;};structAsteroid:Thing{voidcollideWith(Thing&other){// dynamic_cast to a pointer type returns NULL if the cast fails// (dynamic_cast to a reference type would throw an exception on failure)if(autoasteroid=dynamic_cast<Asteroid*>(&other)){// handle Asteroid-Asteroid collision}elseif(autospaceship=dynamic_cast<Spaceship*>(&other)){// handle Asteroid-Spaceship collision}else{// default collision handling here}}};structSpaceship:Thing{voidcollideWith(Thing&other){if(autoasteroid=dynamic_cast<Asteroid*>(&other)){// handle Spaceship-Asteroid collision}elseif(autospaceship=dynamic_cast<Spaceship*>(&other)){// handle Spaceship-Spaceship collision}else{// default collision handling here}}};

#include<cstdint>#include<typeinfo>#include<unordered_map>classThing{protected:Thing(std::uint32_tcid):tid(cid){}conststd::uint32_ttid;// type idtypedefvoid(Thing::*CollisionHandler)(Thing&other);typedefstd::unordered_map<std::uint64_t,CollisionHandler>CollisionHandlerMap;staticvoidaddHandler(std::uint32_tid1,std::uint32_tid2,CollisionHandlerhandler){collisionCases.insert(CollisionHandlerMap::value_type(key(id1,id2),handler));}staticstd::uint64_tkey(std::uint32_tid1,std::uint32_tid2){returnstd::uint64_t(id1)<<32|id2;}staticCollisionHandlerMapcollisionCases;public:voidcollideWith(Thing&other){autohandler=collisionCases.find(key(tid,other.tid));if(handler!=collisionCases.end()){(this->*handler->second)(other);// pointer-to-method call}else{// default collision handling}}};classAsteroid:publicThing{voidasteroid_collision(Thing&other){/*handle Asteroid-Asteroid collision*/}voidspaceship_collision(Thing&other){/*handle Asteroid-Spaceship collision*/}public:Asteroid():Thing(cid){}staticvoidinitCases();staticconststd::uint32_tcid;};classSpaceship:publicThing{voidasteroid_collision(Thing&other){/*handle Spaceship-Asteroid collision*/}voidspaceship_collision(Thing&other){/*handle Spaceship-Spaceship collision*/}public:Spaceship():Thing(cid){}staticvoidinitCases();staticconststd::uint32_tcid;// class id};Thing::CollisionHandlerMapThing::collisionCases;conststd::uint32_tAsteroid::cid=typeid(Asteroid).hash_code();conststd::uint32_tSpaceship::cid=typeid(Spaceship).hash_code();voidAsteroid::initCases(){addHandler(cid,cid,CollisionHandler(&Asteroid::asteroid_collision));addHandler(cid,Spaceship::cid,CollisionHandler(&Asteroid::spaceship_collision));}voidSpaceship::initCases(){addHandler(cid,Asteroid::cid,CollisionHandler(&Spaceship::asteroid_collision));addHandler(cid,cid,CollisionHandler(&Spaceship::spaceship_collision));}intmain(){Asteroid::initCases();Spaceship::initCases();Asteroida1,a2;Spaceships1,s2;a1.collideWith(a2);a1.collideWith(s1);s1.collideWith(s2);s1.collideWith(a1);}

#include<yorel/yomm2/keywords.hpp>#include<memory>classThing{public:virtual~Thing(){}};classAsteroid:publicThing{};classSpaceship:publicThing{};register_classes(Thing,Spaceship,Asteroid);declare_method(void,collideWith,(virtual_<Thing&>,virtual_<Thing&>));define_method(void,collideWith,(Thing&left,Thing&right)){// default collision handling}define_method(void,collideWith,(Asteroid&left,Asteroid&right)){// handle Asteroid-Asteroid collision}define_method(void,collideWith,(Asteroid&left,Spaceship&right)){// handle Asteroid-Spaceship collision}define_method(void,collideWith,(Spaceship&left,Asteroid&right)){// handle Spaceship-Asteroid collision}define_method(void,collideWith,(Spaceship&left,Spaceship&right)){// handle Spaceship-Spaceship collision}intmain(){yorel::yomm2::update_methods();std::unique_ptr<Thing>a1(std::make_unique<Asteroid>()),a2(std::make_unique<Asteroid>());std::unique_ptr<Thing>s1(std::make_unique<Spaceship>()),s2(std::make_unique<Spaceship>());// note: types partially erasedcollideWith(*a1,*a2);// Asteroid-Asteroid collisioncollideWith(*a1,*s1);// Asteroid-Spaceship collisioncollideWith(*s1,*a1);// Spaceship-Asteroid collisioncollideWith(*s1,*s2);// Spaceship-Spaceship collisionreturn0;}

D

// DeclarationMatrixplus(virtual!Matrix,virtual!Matrix);// The override for two DenseMatrix objects@methodMatrix_plus(DenseMatrixa,DenseMatrixb){constintnr=a.rows;constintnc=a.cols;assert(a.nr==b.nr);assert(a.nc==b.nc);autoresult=newDenseMatrix;result.nr=nr;result.nc=nc;result.elems.length=a.elems.length;result.elems[]=a.elems[]+b.elems[];returnresult;}// The override for two DiagonalMatrix objects@methodMatrix_plus(DiagonalMatrixa,DiagonalMatrixb){assert(a.rows==b.rows);double[]sum;sum.length=a.elems.length;sum[]=a.elems[]+b.elems[];returnnewDiagonalMatrix(sum);}

Java

interfaceCollideable{voidcollideWith(finalCollideableother);/* These methods would need different names in a language without method overloading. */voidcollideWith(finalAsteroidasteroid);voidcollideWith(finalSpaceshipspaceship);}classAsteroidimplementsCollideable{publicvoidcollideWith(finalCollideableother){// Call collideWith on the other object.other.collideWith(this);}publicvoidcollideWith(finalAsteroidasteroid){// Handle Asteroid-Asteroid collision.}publicvoidcollideWith(finalSpaceshipspaceship){// Handle Asteroid-Spaceship collision.}}classSpaceshipimplementsCollideable{publicvoidcollideWith(finalCollideableother){// Call collideWith on the other object.other.collideWith(this);}publicvoidcollideWith(finalAsteroidasteroid){// Handle Spaceship-Asteroid collision.}publicvoidcollideWith(finalSpaceshipspaceship){// Handle Spaceship-Spaceship collision.}}

Support in programming languages

Primary paradigm

Supporting general multimethods

Via extensions

See also

References

External links