複数回派遣

多重ディスパッチまたはマルチメソッドは、一部のプログラミング言語の機能であり、関数またはメソッドを実行時の（動的な）型、またはより一般的には、複数の引数のその他の属性に基づいて動的にディスパッチできます。^{[1]これは、関数またはメソッドの呼び出しが、メソッドが呼び出されたオブジェクトの派生型に基づいて動的にディスパッチされる、}単一ディスパッチ多態性の一般化です。多重ディスパッチは、1つ以上の引数の組み合わせ特性を使用して、実装する関数またはメソッドに動的ディスパッチをルーティングします。

コンピュータ ソフトウェアの開発者は、通常、ソース コードを、サブルーチン、プロシージャ、サブプログラム、関数、メソッドなどと呼ばれる名前付きブロックに編成します。関数内のコードは、関数を呼び出すことによって実行されます。つまり、関数の名前を参照するコードを実行します。これにより、呼び出された関数に一時的に制御が渡されます。関数の実行が完了すると、通常、制御は参照に続く 呼び出し元の命令に戻されます。

関数名は通常、関数の目的がわかるように選択されます。複数の関数に同じ名前を付けることが望ましい場合があります。これは、関数が概念的には同様のタスクを実行するものの、異なるタイプの入力データに対して動作することが多いためです。このような場合、関数呼び出しサイトでの名前参照だけでは、実行するコード ブロックを識別するのに十分ではありません。代わりに、関数呼び出しの引数の数とタイプも、複数の関数実装の中から選択するために使用されます。

より従来的な、つまりシングルディスパッチのオブジェクト指向プログラミング言語では、メソッドを呼び出すとき ( Smalltalkではメッセージを送信し、C++ではメンバー関数を呼び出します)、その引数の 1 つが特別に扱われ、その名前のメソッドのクラス (潜在的に多数) のうちどれを適用するかを決定するために使用されます。多くの言語では、特別な引数は構文で示されます。たとえば、多くのプログラミング言語では、メソッド呼び出しを行う際に特別な引数をドットの前に置きます。なので、 では轟音が鳴り、 ではさえずり音が鳴ります。 special.method(other, arguments, here)lion.sound()sparrow.sound()

対照的に、多重ディスパッチを持つ言語では、選択されるメソッドは、単に、関数呼び出しの数と型に一致する引数を持つメソッドです。特定の呼び出しで実行される関数/メソッドを所有する特別な引数はありません。

Common Lisp Object System (CLOS) は、多重ディスパッチの初期のよく知られた例です。多重ディスパッチの使用に関するもう 1 つの注目すべき例は、Juliaプログラミング言語です。

多重ディスパッチは、関数オーバーロードとは区別する必要があります。関数オーバーロードでは、項の宣言型または推論型 (またはサブタイプを持つ言語の基本型) などの静的型付け情報を使用して、特定の呼び出しサイトで複数の可能性のうちどれを使用するかを決定します。この決定は、コンパイル時またはリンク時 (またはプログラムの実行開始前の他の時点) に行われ、その後はプログラムの特定の展開または実行に対して不変です。C++ などの多くの言語では、堅牢な関数オーバーロードが提供されていますが、動的な多重ディスパッチは提供されていません (C++ では、仮想関数の使用による動的単一ディスパッチのみが許可されます)。

コンパイル時にデータ型を区別できる言語を使用する場合、そのときに選択肢から選択することができます。コンパイル時に選択するためのこのような代替関数を作成する行為は、通常、関数の オーバーロードと呼ばれます。

データ型の識別を実行時まで延期するプログラミング言語 (つまり、遅延バインディング) では、動的に決定された関数引数の型に基づいて、代替関数の選択が実行時に行われる必要があります。このように代替実装が選択される関数は、一般的にマルチメソッドと呼ばれます。

関数呼び出しを動的にディスパッチすることには、実行時のコストが伴います。一部の言語では、^{[引用が必要]}オーバーロードとマルチメソッドの区別があいまいになる場合があり、コンパイラは、特定の関数呼び出しにコンパイル時の選択を適用できるかどうか、またはより遅い実行時のディスパッチが必要かどうかを決定します。

動的ディスパッチには、単一および複数の両方の既知の問題がいくつかあります。これらの問題の多くは、数十年にわたってオブジェクト指向プログラミング言語の標準機能であった単一ディスパッチでは解決されていますが、多重ディスパッチの場合はこれらの問題がより複雑になります。

一般的なプログラミング言語のほとんどでは、ソース コードは機能の粒度で配信および展開されます。ここではこれをパッケージと呼びます。この概念の実際の用語は言語によって異なります。各パッケージには複数の型、値、および関数の定義が含まれる場合があり、パッケージはコンパイル ステップのある言語では個別にコンパイルされることが多く、非循環的な依存関係が存在する場合があります。完全なプログラムはパッケージのセットであり、メイン パッケージは他のいくつかのパッケージに依存する可能性があり、プログラム全体は依存関係の推移的な閉包で構成されます。

いわゆる式の問題は、依存パッケージのコードが、ベース パッケージのソースを変更することなく、インクルード パッケージ内からベース パッケージで定義された動作 (関数またはデータ型) を拡張できるかどうかに関係します。従来のシングル ディスパッチの OO 言語では、新しいデータ型を追加するのは簡単ですが、新しい関数を追加するのは簡単ではありません。従来の関数型言語ではその逆の効果があり、正しく実装されていれば、多重ディスパッチでは両方が可能になります。多重ディスパッチの実装には、次の特性があることが望ましいです。

• 基本パッケージのソースを変更せずに、異なるパッケージ内からマルチメソッドの異なる「ケース」を定義することができます。
• プログラムに別のパッケージを含めても、呼び出しがパッケージで定義されたデータ型を使用しない場合、特定のマルチメソッド呼び出しの動作は変更されません。
• 逆に、あるパッケージでデータ型が定義され、その型を使用するマルチメソッド拡張も同じパッケージで定義され、その型の値が (基本型参照またはジェネリック関数を介して) そのパッケージに依存しない別のパッケージに渡され、その値を引数としてマルチメソッドが呼び出される場合は、その型を含むパッケージで定義されたマルチメソッドのケースを使用する必要があります。言い換えると、特定のプログラム内で、同じ引数セットで呼び出された同じマルチメソッドは、呼び出しサイトの場所や、メソッド呼び出しの時点で特定の定義が「スコープ内」または「可視」であるかどうかに関係なく、同じ実装に解決される必要があります。

一般的に、マルチメソッドの任意の呼び出しに対して、マルチメソッドの実装ケースの中で「最良」の候補が最大で 1 つ存在すること、および/または、存在しない場合は、失敗を含めて予測可能かつ決定論的な方法で解決されることが望ましいです。非決定論的な動作は望ましくありません。非循環的なサブタイプ関係を持つ型のセットを想定すると、最初のすべての動的ディスパッチ引数が 2 番目のすべての動的ディスパッチ引数のサブタイプであり、少なくとも 1 つが厳密なサブタイプである場合、マルチメソッドの 1 つの実装が「より優れている」(より具体的である) と定義できます。単一ディスパッチで多重継承がない場合、この条件は自明に満たされますが、多重ディスパッチでは、2 つ以上の候補が特定の実引数リストを満たす可能性がありますが、どちらも他よりも具体的ではありません (1 つの動的引数が 1 つのケースのサブタイプであり、別の動的引数が他のケースのサブタイプである)。これは特に、どちらも他のパッケージに依存しない 2 つの異なるパッケージが、それぞれのパッケージの型に関する実装を持つマルチメソッドを拡張し、その後、両方を含む (おそらく間接的に) 3 番目のパッケージが両方のパッケージの引数を使用してマルチメソッドを呼び出す場合に発生する可能性があります。

考えられる解決策は次のとおりです。

• あいまいな呼び出しをエラーとして扱います。これはコンパイル時 (またはデプロイメント前) に検出される可能性がありますが、実行時まで検出されず、実行時エラーが発生する可能性があります。
• 引数の順序付け。たとえば、最も具体的な最初の引数を持つケースが選択され、最初の引数が問題を解決するのに不十分でない限り、後続の引数は曖昧さの解決には考慮されません。
• いずれかの方向の曖昧さを解決するための他のルールの構築。場合によっては、このようなルールは恣意的で意外な場合があります。たとえば、C++ の静的オーバーロード解決のルールでは、完全に一致する型は、当然のことながら、基本型参照またはジェネリック (テンプレート) パラメータを介して一致する型よりも優れた一致と見なされます。ただし、一致する可能性のあるのが基本型またはジェネリック パラメータのいずれかである場合は、ジェネリック パラメータが基本型よりも優先されます。このルールは、意外な動作を引き起こすことがあります。

シングルディスパッチの効率的な実装は、プログラムロード/起動時に動的に、またはアプリケーションコードの指示の下でも、オブジェクトコードに個別にコンパイルされ、低レベル（言語非対応）リンカーでリンクされるプログラミング言語を含む、よく知られています。C++ やその他の初期の OO 言語で開発された「vtable」メソッド（各クラスには、そのクラスの仮想関数に対応する関数ポインターの配列があります）は、静的メソッド呼び出しとほぼ同じくらい高速で、最適化されていない場合でも、O(1) のオーバーヘッドと 1 回の追加メモリ検索のみを必要とします。ただし、vtable メソッドは、検索キーとして引数の型ではなく関数名を使用するため、マルチディスパッチのケースには拡張できません。（また、メソッドがクラスの機能であり、特定のデータ型から独立したスタンドアロンのエンティティではないというオブジェクト指向パラダイムにも依存します）。

マルチディスパッチの効率的な実装は、現在も進行中の研究課題です。

実際に多重ディスパッチがどの程度頻繁に使用されているかを推定するために、Muscheviciら^[2]は動的ディスパッチを使用するプログラムを研究した。彼らは、Common Lisp Object System、Dylan、Cecil、MultiJava、Diesel、Niceの6つの異なる言語で書かれた、主にコンパイラである9つのアプリケーションを分析した。その結果、ジェネリック関数の13～32%が1つの引数の動的型を使用し、2.7～6.5%が複数の引数の動的型を使用していることがわかった。ジェネリック関数の残りの65～93%は1つの具体的なメソッド（オーバーライド）を持っているため、引数の動的型を使用しているとは考えられない。さらに、この研究では、ジェネリック関数の2～20%が2つの具体的な関数実装を持ち、3～6%が3つの具体的な関数実装を持っていたと報告されている。より具体的なオーバーライドを持つ関数では、その数は急速に減少する。

多重ディスパッチは、言語の起源から中心的な設計概念であったJuliaでより頻繁に使用されています。Muscheviciと同じ統計を収集して、ジェネリック関数あたりのメソッドの平均数を調べてみると、Juliaの標準ライブラリは、Muscheviciが分析した他の言語よりも2倍以上のオーバーロードを使用しており、二項演算子の場合は10倍以上であることがわかりました。^[3]

これらの論文のデータは、次の表にまとめられています。ディスパッチ率は、DRジェネリック関数あたりのメソッドの平均数です。選択率はCR、メソッドの数の2乗の平均です（メソッドの数が多い関数の頻度をより正確に測定するため）^{[2] [3]。}特化の度合いは、DoSメソッドあたりの型特化引数の平均数（つまり、ディスパッチされる引数の数）です。

多重ディスパッチ言語の理論は、遅延バインディングによるオーバーロード関数のモデルを定義することによって、Castagnaらによって最初に開発されました。^{[4] [5]}これにより、オブジェクト指向言語の共変性と反変性の問題が初めて形式化され、 ^[6]バイナリメソッドの問題が解決されました。^[7]

複数ディスパッチと単一ディスパッチの区別は、例を挙げるとより明確になります。宇宙船や小惑星などの (ユーザーに見える) オブジェクトがあるゲームを想像してください。2 つのオブジェクトが衝突すると、プログラムは何が何に衝突したかに応じて異なる処理を実行する必要があるかもしれません。

C# はバージョン 4 ^[8] (2010 年 4 月) で 'dynamic' キーワードを使用して動的マルチメソッドのサポートを導入しました。次の例はマルチメソッドを示しています。他の多くの静的型付け言語と同様に、C# も静的メソッドのオーバーロードをサポートしています。^[9] Microsoft は、ほとんどのシナリオで開発者が動的型付けよりも静的型付けを選択することを期待しています。^[10] 'dynamic' キーワードは、COM オブジェクトおよび動的型付けの .NET 言語との相互運用性をサポートします。

以下の例では、C# 9 および C# 10 で導入された機能を使用しています。

静的ColliderLibraryを使用します。  

Console.WriteLine ( Collide (新しい小惑星( 101 ) 、新しい宇宙船( 300 ))); Console.WriteLine ( Collide (新しい小惑星( 10 ) 、新しい宇宙船( 10 ) )); Console.WriteLine ( Collide (新しい宇宙船( 101 ) 、新しい宇宙船( 10 ) ) );   
   
   

string Collide ( SpaceObject x , SpaceObject y ) => x . Size > 100 && y . Size > 100 ? "Big boom!" : CollideWith ( x as dynamic , y as dynamic ); // CollideWith メソッドへの動的ディスパッチ     
          
         
               

クラスColliderLibrary { public static string CollideWith (小惑星x 、小惑星y ) => "a/a" ; public static string CollideWith (小惑星x 、宇宙船y ) => "a/s" ; public static string CollideWith (宇宙船x 、小惑星y ) => "s/a" ; public static string CollideWith (宇宙船x 、宇宙船y ) => "s/s" ; } 

            
            
            
            


抽象レコードSpaceObject ( int Size );レコードAsteroid ( int Size ) : SpaceObject ( Size );レコードSpaceship ( int Size ) : SpaceObject ( Size );   
    
    

出力：

ビッグブーム！
a/s 
s/s

GroovyはJavaと互換性があり相互利用可能な汎用JVM言語であり、Javaとは異なり、遅延バインディング/多重ディスパッチを使用します。^[11]

/*
    上記の C# の例の Groovy 実装
    遅延バインディングは、非静的メソッドを使用する場合でも、クラス/メソッドを静的にコンパイルする場合も同じように機能します
    (@CompileStatic アノテーション) 
*/ 
class Program { static void main ( String [] args ) { println Collider . collide ( new Asteroid ( 101 ), new Spaceship ( 300 )) println Collider . collide ( new Asteroid ( 10 ), new Spaceship ( 10 )) println Collider . collide ( new Spaceship ( 101 ), new Spaceship ( 10 )) } }  
        
            
            
            
    


クラスCollider { static String collide ( SpaceObject x , SpaceObject y ) { ( x . size > 100 && y . size > 100 ) ? "big-boom" : collideWith ( x , y ) // collideWith メソッドへの動的ディスパッチ}  
          
                     
    

    プライベート静的文字列collideWith (小惑星x 、小惑星y ) { "a/a" }プライベート静的文字列collideWith (小惑星x 、宇宙船y ) { "a/s" }プライベート静的文字列collideWith (宇宙船x 、小惑星y ) { "s/a" }プライベート静的文字列collideWith (宇宙船x 、宇宙船y ) { "s/s" } }         
             
             
            


クラスSpaceObject { int size SpaceObject ( int size ) { this . size = size } }  
     
          


@InheritConstructorsクラスAsteroidはSpaceObject {}を拡張します@InheritConstructorsクラスSpaceship はSpaceObject {}を拡張します     
     

Common Lispなどの多重ディスパッチを持つ言語では、次のようになります (Common Lisp の例を示します)。

( defmethod collide-with (( x小惑星) ( y小惑星)) ;; 小惑星が小惑星に衝突する場合の処理​​ ) ( defmethod collide-with (( x小惑星) ( y宇宙船)) ;; 小惑星が宇宙船に衝突する場合の処理​​ ) ( defmethod collide-with (( x宇宙船) ( y小惑星)) ;; 宇宙船が小惑星に衝突する場合の処理​​ ) ( defmethod collide-with (( x宇宙船) ( y宇宙船)) ;; 宇宙船が宇宙船に衝突する場合の処理​​ )     
  
  
     
  
  
     
  
  
     
  
  

他のメソッドについても同様です。明示的なテストと「動的キャスト」は使用されません。

多重ディスパッチが存在する場合、メソッドはクラスで定義され、オブジェクトに含まれるという従来の考え方は魅力が薄れます。上記の各衝突メソッドは、1 つのクラスではなく 2 つの異なるクラスに関連付けられます。したがって、メソッド呼び出しの特別な構文は一般に消え、メソッド呼び出しは通常の関数呼び出しとまったく同じように見え、メソッドはクラスではなくジェネリック関数にグループ化されます。

Juliaには多重ディスパッチが組み込まれており、それが言語設計の中心となっています。^[3] 上記の例のJuliaバージョンは次のようになります。

抽象型SpaceObject終了   

構造体 Asteroid <: SpaceObjectサイズ:: Int終了構造体Spaceship <: SpaceObjectサイズ:: Int終了  
        

   
                      


collide_with ( ::小惑星、::宇宙船) = "a/s" collide_with ( ::宇宙船、::小惑星) = "s/a" collide_with ( ::宇宙船、::宇宙船) = "s/s" collide_with ( ::小惑星、::小惑星) = "a/a"   
   
   
   

collide ( x :: SpaceObject , y :: SpaceObject ) = ( x . size > 100 && y . size > 100 ) ? 「ビッグドカン！」: collide_with ( x , y )              

出力：

julia>衝突(小惑星( 101 )、宇宙船( 300 )) 「ビッグドカン！」  


ジュリア>衝突(小惑星( 10 )、宇宙船( 10 )) "a/s"  


ジュリア>衝突(宇宙船( 101 )、宇宙船( 10 )) "s/s"  

Rakuは Perl と同様に、他の言語の実証済みのアイデアを使用しており、型システムはコンパイラ側のコード分析と多重ディスパッチによる強力なユーザー側セマンティクスにおいて魅力的な利点を提供することが実証されています。

マルチメソッドとマルチサブの両方を備えています。ほとんどの演算子はサブルーチンであるため、複数のディスパッチ演算子も備えています。

通常の型制約に加えて、非常に特殊なサブルーチンを作成できる where制約もあります。

 RealのサブセットMass  、0 ^..^ Inf ; 
役割Stellar-Object {
     Mass $.massが必要;
    メソッド名() はStr { ...}を返します;          
}
クラス Asteroid は Stellar-Object {
    メソッド名() { 'an asteroid' }を実行します。  
}
クラス Spaceship は Stellar-Object {
     Str $.name = 'some unnamed spaceship'を持っています 。  
}
my  Str  @destroyed = <破壊された 破壊された 破損した>;
 my  Str  @damaged = « 破損した '衝突した'  'によって損傷を受けた'  »;

# 数値比較演算子には複数の候補を追加します。数値的に比較しているためです
が、オブジェクトを Numeric 型に強制変換するのは意味がありません。
# (強制変換する場合は、必ずしもこれらの演算子を追加する必要はありません。) 
# まったく新しい演算子を同じ方法で定義することもできます。
multi  sub  infix: « <=> » ( Stellar-Object:D  $a、Stellar-Object:D  $b ) { $a . mass <=> $b . mass }
 multi  sub  infix: « < » ( Stellar-Object:D  $a、Stellar-Object:D  $b ) { $a . mass < $b . mass }
 multi  sub  infix: « > » ( Stellar-Object:D  $a、Stellar-Object:D  $b ) { $a . mass > $b . mass }
マルチ サブ インフィックス: « == » ( Stellar-Object:D  $a、Stellar-Object:D  $b ) { $a . mass == $b . mass }

# 新しいマルチディスパッチャーを定義し、パラメーターにいくつかの型制約を追加します。
# 定義しなかった場合は、制約のない汎用ディスパッチャーが作成されます。
proto  sub  collide ( Stellar-Object:D $, Stellar-Object:D $ ) {*}

# 型はプロトタイプと同じなので、ここで繰り返す必要はありません。
# 'where' 制約は技術的には $b にのみ適用され、シグネチャ全体には適用されません。
# 'where' 制約では、先ほど追加した `<` 演算子候補が使用されることに注意してください。
multi  sub  collide ( $a , $b  where  $a < $b ) {
     say  "$a.name() was @destroyed.pick() by $b.name()" ;
}
multi  sub  collide ( $a , $b  where  $a > $b ) {
     # 引数を入れ替えて前の候補に再ディスパッチします
    samewith  $b , $a ;
}

# 他の 2 つには'where' 制約があり、
サブルーチンが記述された順序でチェックされるため、これは最初の 2 つの後である必要があります。(これは常に一致します。) 
multi sub collide ( $a , $b ) {
     # 順序をランダム化しますmy ( $n1 , $n2 ) = ( $a . name , $b . name ). pick (*);
     say "$n1 @damaged.pick() $n2" ;
  
     
}


# 次の 2 つの候補は、前の 3 つよりも特殊化された型であるため、proto の後のどこにでも配置できます。

# 宇宙船の質量が異なる場合は、最初の 2 つの候補のうちの 1 つが代わりに呼び出されます。
multi  sub  collide ( Spaceship  $a、Spaceship  $b  where  $a == $b ){
     my ( $n1、$n2 ) = ( $a . name、$b . name ). pick (*);
     say  "$n1 が $n2 と衝突し、両方の宇宙船が "、
    ( @destroyed . pick , '損傷したまま' ). pick ;
}

# 属性をシグネチャ内の変数に展開できます。
# 属性に制約 `(:mass($a) where 10)` を設定することもできます。
multi  sub  collide ( Asteroid $ (: mass ( $a )), Asteroid $ (: mass ( $b )) ){
     「2 つの小惑星が衝突し、質量 { $a + $b } の 1 つの大きな小惑星に結合されました」とします 。
}

私の 宇宙船 $Enterprise .= new (: mass ( 1 ),: name ( 'The Enterprise' ));
小惑星. new (: mass ( .1 )), $Enterpriseと衝突します。 $ Enterprise
 、宇宙船. new ( : mass ( .1 ) );
 $Enterprise、小惑星. new (: mass ( 1 ));
 $Enterprise、宇宙船. new (: mass ( 1 ) ) ;
小惑星. new (: mass ( 10 )),小惑星. new ( : mass ( 5 ));
    

言語定義や構文レベルで多重ディスパッチをサポートしていない言語では、ライブラリ拡張を使用して多重ディスパッチを追加できる場合がよくあります。JavaScriptとTypeScriptは構文レベルでマルチメソッドをサポートしていませんが、ライブラリを介して多重ディスパッチを追加することは可能です。たとえば、マルチメソッドパッケージ^[12]は、多重ディスパッチの汎用関数の実装を提供します。

JavaScript の動的型付けバージョン:

'@arrows/multimethod'から{ multi , method }をインポートします。      

クラスAsteroid {}クラスSpaceship {}  
  

const collideWith = multi ( method ([ Asteroid , Asteroid ], ( x , y ) => { // 小惑星の衝突を処理}), method ([ Asteroid , Spaceship ], ( x , y ) => { // 小惑星の衝突を処理}), method ([ Spaceship , Asteroid ], ( x , y ) => { // 小惑星の衝突を処理}), method ([ Spaceship , Spaceship ], ( x , y ) => { // 宇宙船の衝突を処理}), )   
       
    
  
       
    
  
       
    
  
       
    
  

TypeScript の静的型付けバージョン:

'@arrows/multimethod'から{ multi , method , Multi }をインポートします。       

クラスAsteroid {}クラスSpaceship {}  
  

タイプCollideWith = Multi & { ( x :小惑星、y :小惑星) : void ( x :小惑星、y :宇宙船) : void ( x :宇宙船、y :小惑星) : void ( x :宇宙船、y :宇宙船) : void }     
      
      
      
      


const collideWith : CollideWith = multi ( method ([ Asteroid , Asteroid ], ( x , y ) => { // 小惑星の衝突を処理}), method ([ Asteroid , Spaceship ], ( x , y ) => { // 小惑星の衝突を処理}), method ([ Spaceship , Asteroid ], ( x , y ) => { // 小惑星の衝突を処理}), method ([ Spaceship , Spaceship ], ( x , y ) => { // 宇宙船の衝突を処理}), )    
       
    
  
       
    
  
       
    
  
       
    
  

ライブラリ拡張を使用して、Pythonに多重ディスパッチを追加することができます。たとえば、モジュールmultimethod.py ^[13]やモジュールmultimethods.py ^{[14]を使用すると、言語の基礎となる構文やキーワードを変更せずに、} PythonにCLOSスタイルのマルチメソッドが提供されます。

 multimethods からDispatchをインポート game_objectsからAsteroid 、Spaceshipをインポートgame_behaviorsからas_func 、ss_func 、sa_funcをインポート
    
     

collide  =  Dispatch () 
collide . add_rule ((小惑星, 宇宙船),  as_func ) 
collide . add_rule ((宇宙船, 宇宙船), ss_func ) collide . add_rule ((宇宙船,小惑星), sa_func ) 
  

def  aa_func ( a ,  b ): 
"""小惑星が小惑星に衝突したときの動作。""" # ...新しい動作を定義...    
    

衝突します。add_rule ((小惑星,小惑星), aa_func )  

# ...後で...
衝突( thing1 、 thing2 )

機能的には、これは CLOS の例と非常に似ていますが、構文は従来の Python です。

Guido van RossumはPython 2.4のデコレータを使用して、簡略化された構文を持つ マルチメソッドのサンプル実装^{[15]を作成しました。}

@multimethod ( Asteroid ,  Asteroid ) 
def  collide ( a ,  b ): 
"""小惑星が小惑星に衝突したときの動作。""" # ...新しい動作を定義... @multimethod ( Asteroid , Spaceship ) def collide ( a , b ): """小惑星が宇宙船に衝突したときの動作。""" # ...新しい動作を定義... # ...その他のマルチメソッド ルールを定義...    
    
 
  
    
    

次に、マルチメソッド デコレータを定義します。

PEAK-Rulesパッケージは、上記の例に似た構文で多重ディスパッチを提供します。^[16]これは後にPyProtocolsに置き換えられました。^[17]

Regライブラリは多重ディスパッチと述語ディスパッチもサポートしています。^[18]

型ヒント の導入により、さらに簡単な構文で多重ディスパッチが可能になります。たとえば、plum-dispatchを使用すると、

プラム 輸入発送​  

@dispatch 
def  collide ( a :  Asteroid ,  b :  Asteroid ): 
"""小惑星が小惑星に衝突したときの動作。""" # ...新しい動作を定義...    
    
    
@dispatch 
def  collide ( a :  Asteroid ,  b :  Spaceship ): 
"""小惑星が宇宙船に衝突したときの動作。""" # ...新しい動作を定義...    
    
    
# ...さらにルールを定義します...

C には動的ディスパッチがないため、何らかの形で手動で実装する必要があります。多くの場合、列挙型はオブジェクトのサブタイプを識別するために使用されます。動的ディスパッチは、関数ポインター 分岐テーブルでこの値を検索することによって実行できます。以下は C での簡単な例です。

typedef void ( *衝突ケース)( void );  

void collision_AA ( void ) { /* 小惑星同士の衝突を処理 */ }; void collision_AS ( void ) { /* 小惑星同士の衝突を処理 */ }; void collision_SA ( void ) { /* 宇宙船同士の小惑星の衝突を処理 */ }; void collision_SS ( void ) { /* 宇宙船同士の衝突を処理 */ };    
    
    
    

typedef enum { THING_ASTEROID = 0 、THING_SPACESHIP 、THING_COUNT /* それ自体は物のタイプではなく、物の数を見つけるために使用されます */ } Thing ;  
      
    
     
 

衝突ケースcollisionCases [ THING_COUNT ][ THING_COUNT ] = { { & collision_AA 、& collision_AS }, { & collision_SA 、& collision_SS } };   
     
     


void衝突(物体a 、物体b ) { ( * collisionCases [ a ][ b ])(); }     
    


int main ( void ) {衝突( THING_SPACESHIP 、THING_ASTEROID ); }  
     

Cオブジェクトシステムライブラリ^[19]では、 CはCLOSと同様の動的ディスパッチをサポートしています。これは完全に拡張可能であり、メソッドを手動で処理する必要はありません。動的メッセージ（メソッド）はCOSのディスパッチャによってディスパッチされ、Objective-Cよりも高速です。以下はCOSでの例です。

#include <stdio.h> #include <cos/Object.h> #include <cos/gen/object.h> 
 
 

// クラス

defclass ( Asteroid ) // データメンバーendclass 



defclass ( Spaceship ) // データメンバーendclass 



// ジェネリック

defgeneric ( _Bool 、collide_with 、_1 、_2 );    

// マルチメソッド

defmethod ( _Bool , collide_with , Asteroid , Asteroid ) // 小惑星の衝突を処理する 小惑星の衝突を処理するendmethod    
 


defmethod ( _Bool , collide_with , Asteroid , Spaceship ) // 小惑星が宇宙船に衝突した場合の処理​​ endmethod    
 


defmethod ( _Bool , collide_with , Spaceship , Asteroid ) // 宇宙船が小惑星に衝突した場合の処理​​ endmethod    
 


defmethod ( _Bool , collide_with , Spaceship , Spaceship ) // 宇宙船が宇宙船に衝突した場合の処理​​ endmethod    
 


// 使用例

int main ( void ) { OBJ a = gnew (小惑星); OBJ s = gnew (宇宙船); 

     
     

  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 ); }  

2021年現在^{[アップデート]}、C++はネイティブでは単一のディスパッチのみをサポートしていますが、 2007年にBjarne Stroustrup （および協力者）によって複数のメソッド（複数のディスパッチ）の追加が提案されました。^[20]この制限を回避する方法は類似しており、ビジターパターン、動的キャスト、またはライブラリのいずれかを使用します。

 // dynamic_cast による実行時の型比較の例

 構造体Thing {仮想void collideWith ( Thing & other ) = 0 ; };  
          
 

 struct Asteroid : Thing { void collideWith ( Thing & other ) { // ポインター型への dynamic_cast は、キャストが失敗した場合は NULL を返します// (参照型への dynamic_cast は、失敗すると例外をスローします) if ( auto asteroid = dynamic_cast < Asteroid *> ( & other )) { // 小惑星間の衝突を処理します} else if ( auto spaceship = dynamic_cast < Spaceship *> ( & other )) { // 小惑星間の宇宙船の衝突を処理します} else { // ここでデフォルトの衝突処理} } };    
        
         
         
              
             
                
             
           
             
         
     
 

 struct Spaceship : Thing { void collideWith ( Thing & other ) { if ( auto asteroid = dynamic_cast < Asteroid *> ( & other )) { // 宇宙船と小惑星の衝突を処理する} else if ( auto spaceship = dynamic_cast < Spaceship *> ( & other )) { // 宇宙船と宇宙船の衝突を処理する} else { // ここでデフォルトの衝突処理} } };    
        
              
             
                
             
           
             
         
     
 

またはメソッドへのポインタ検索テーブル:

#include <cstdint> #include <typeinfo> #include <unordered_map> 
 
 

クラスThing { protected : Thing ( std :: uint32_t cid ) : tid ( cid ) {} const std :: uint32_t tid ; // 型 id  
  
        
       

    typedef void ( Thing ::* CollisionHandler )( Thing & other ); typedef std :: unordered_map < std :: uint64_t , CollisionHandler > CollisionHandlerMap ;   
       

    static void addHandler ( std :: uint32_t id1 、std :: uint32_t id2 、CollisionHandlerハンドラー) { collisionCases . insert ( CollisionHandlerMap :: value_type ( key ( id1 、id2 )、handler )); } static std :: uint64_t key ( std :: uint32_t id1 、std :: uint32_t id2 ) { return std :: uint64_t ( id1 ) << 32 | id2 ; }        
          
    
          
             
    

    静的CollisionHandlerMap衝突ケース;  

  public : 
void collideWith ( Thing & other ) { auto handler = collisionCases . find ( key ( tid , other . tid )); if ( handler != collisionCases . end ()) { ( this ->* handler -> second )( other ); // ポインターからメソッドへの呼び出し} else { // デフォルトの衝突処理} } };       
            
            
             
          
            
        
    


class Asteroid : public Thing { void asteroid_collision ( Thing & other ) { /* 小惑星同士の衝突を処理 */ } void spaceship_collision ( Thing & other ) { /* 小惑星と宇宙船の衝突を処理 */ }    
           
         

  public : 
Asteroid () : Thing ( cid ) {} static void initCases (); static const std :: uint32_t cid ; };      
      
       


クラスSpaceship : public Thing { void asteroid_collision ( Thing & other ) { /* 宇宙船と小惑星の衝突を処理 */ } void spaceship_collision ( Thing & other ) { /* 宇宙船と宇宙船の衝突を処理 */ }    
          
         

  public : 
Spaceship () : Thing ( cid ) {} static void initCases (); static const std :: uint32_t cid ; // クラス ID };      
      
        


Thing :: CollisionHandlerMap Thing :: collisionCases ; const std :: uint32_t Asteroid :: cid = typeid ( Asteroid ). hash_code () ; const std :: uint32_t Spaceship :: cid = typeid ( Spaceship ). hash_code (); 
    
    

void Asteroid::initCases () { addHandler ( cid 、cid 、CollisionHandler ( & Asteroid :: asteroid_collision )); addHandler ( cid 、Spaceship :: cid 、CollisionHandler ( & Asteroid :: spaceship_collision )); }  
      
      


void Spaceship::initCases () { addHandler ( cid 、Asteroid :: cid 、CollisionHandler ( & Spaceship :: asteroid_collision )); addHandler ( cid 、cid 、CollisionHandler ( & Spaceship :: spaceship_collision )); }  
      
      


int main () {小惑星:: initCases ();宇宙船:: initCases ();  
    
    

    小惑星a1 、a2 ;宇宙船s1 、s2 ;   
      

    a1 .衝突( a2 ); 
a1 .衝突( s1 );    

    s1.collideWith ( s2 ) ; s1.collideWith ( a1 ) ; }​​