ジェネリックプログラミング

ジェネリックプログラミングは、アルゴリズムが後で指定されるデータ型で記述され、パラメータとして提供される特定の型に対して必要に応じてインスタンス化されるコンピュータプログラミングのスタイルです。1973年にプログラミング言語MLで開拓されたこのアプローチ^{[1] [2]により、使用時に動作する型の}セットのみが異なる共通の関数またはデータ型を記述できるため、重複コードが削減されます。

ジェネリックプログラミングは1977年にAdaで主流になりました。C ++のテンプレートにより、ジェネリックプログラミングはプロフェッショナルなライブラリ設計のレパートリーの一部になりました。この技術はさらに改良され、1994年の影響力のある書籍「デザインパターン」でパラメータ化された型が導入されました。^[3]

新しい手法は、 Andrei Alexandrescuが2001 年に出版した著書「Modern C++ Design : Generic Programming and Design Patterns Applied」で紹介されました。その後、D でも同じアイデアが実装されました。

このようなソフトウェア エンティティは、Ada、C#、Delphi、Eiffel、F#、Java、Nim、Python、Go、Rust、Swift、TypeScript、Visual Basic (.NET)ではジェネリックと呼ばれます。 ML、Scala、Julia、Haskellでは、パラメトリック ポリモーフィズムと呼ばれます。 (Haskell の用語でも、関連しているが多少異なる概念に対して ジェネリックという用語が使用されています。)

ジェネリックプログラミングという用語は、もともとDavid MusserとAlexander Stepanov ^[4]によって上記よりも具体的な意味で造られ、データ型に関する基本的な要件がアルゴリズムとデータ構造の具体的な例から抽象化され、概念として形式化され、これらの概念に基づいて実装されたジェネリック関数、通常は上記で説明した言語のジェネリック性メカニズムを使用するプログラミングパラダイムを説明するために使用されました。

ジェネリックプログラミングはMusser & Stepanov (1989)で次のように定義されています。

ジェネリックプログラミングは、具体的で効率的なアルゴリズムを抽象化して、さまざまなデータ表現と組み合わせてさまざまな有用なソフトウェアを作成できるジェネリックアルゴリズムを取得するという考えに基づいています。

— マッサー、デビッド・R.、ステパノフ、アレクサンダー・A.、ジェネリックプログラミング^[5]

「ジェネリックプログラミング」パラダイムは、ソフトウェア分解のアプローチであり、抽象代数における代数理論の抽象化と同様に、アルゴリズムとデータ構造の具体的な例全体から型に関する基本的な要件を抽象化し、概念として形式化します。^[6]このプログラミングアプローチの初期の例はSchemeとAdaで実装されましたが、^[7]最もよく知られている例は標準テンプレートライブラリ（STL）です。^{[8] [9]これは、シーケンスデータ構造とそれを操作するアルゴリズムを分離するために使用される}反復子の理論を開発しました。

たとえば、N 個のシーケンス データ構造 (単方向リンク リスト、ベクトルなど) と、それらを操作するMfind個のアルゴリズム (など) がある場合sort、直接的なアプローチでは、各データ構造に対して各アルゴリズムを具体的に実装し、実装するN × M の組み合わせが提供されます。ただし、ジェネリック プログラミング アプローチでは、各データ構造は反復子の概念 (現在の値を取得するために逆参照したり、シーケンス内の別の値を指すように変更したりできる単純な値型) のモデルを返し、各アルゴリズムは代わりに、処理するサブシーケンスまたは範囲の先頭と末尾を指す反復子のペアなど、そのような反復子の引数を使用して汎用的に記述されます。したがって、実装する必要があるデータ構造とアルゴリズムの組み合わせはN + M 個だけです。 STL では、いくつかの反復子の概念が規定されており、それぞれがより制限的な概念の改良版である。たとえば、順方向反復子はシーケンス内の次の値への移動のみを提供する (たとえば、単方向リンク リストまたは入力データのストリームに適している) のに対し、ランダム アクセス反復子はシーケンスの任意の要素への直接定数時間アクセスも提供する (たとえば、ベクトルに適している)。重要な点は、データ構造は、効率的に実装できる最も一般的な概念のモデルを返すということである。計算の複雑さの要件は、概念の定義に明示的に含まれている。これにより、特定のアルゴリズムを適用できるデータ構造が制限され、このような複雑さの要件は、データ構造の選択の主要な決定要因となる。ジェネリック プログラミングは、グラフ アルゴリズムなどの他のドメインにも同様に応用されている。^[10]

このアプローチは、コンパイル時のジェネリック性とテンプレートの言語機能を使用することが多いが、特定の言語技術の詳細とは独立している。ジェネリックプログラミングの先駆者であるアレクサンダー・ステパノフは次のように書いている。

ジェネリックプログラミングとは、アルゴリズムとデータ構造を抽象化して分類することです。これは型理論ではなく、 Knuthからインスピレーションを得ています。その目標は、有用で効率的で抽象的なアルゴリズムとデータ構造の体系的なカタログを段階的に構築することです。このような取り組みは、まだ夢の段階です。

— アレクサンダー・ステパノフ、STLの短い歴史^{[11] [12]}

環やバナッハ空間の理論が数学において中心的なものであるのと同様に、反復子理論はコンピュータ サイエンスにおいて中心的なものであると私は信じています。

— アレクサンダー・ステパノフ、A.ステパノフとのインタビュー^[13]

ビャルネ・ストロストルップ氏は次のように述べた。

Stepanov に従えば、言語機能について言及せずにジェネリック プログラミングを定義できます。つまり、アルゴリズムとデータ構造を具体的な例から最も一般的で抽象的な形式に引き上げるということです。

— ビャーネ・ストロウストルップ、現実世界のための言語の進化：C++ 1991-2006 ^[12]

ジェネリックプログラミングとして説明されている他のプログラミングパラダイムには、「ジェネリックプログラミング入門」で説明されているデータ型ジェネリックプログラミングがあります。 ^[14]定型句を廃棄するアプローチは、Haskell の軽量なジェネリックプログラミングアプローチです。^[15]

この記事では、上記のジェネリックプログラミングの高レベルプログラミングパラダイムと、それを実装するために使用される低レベルプログラミング言語のジェネリック性メカニズムを区別します（プログラミング言語によるジェネリック性のサポートを参照）。ジェネリックプログラミングパラダイムの詳細な議論と比較については、 ^[16]を参照してください。

ジェネリシティ機能は、少なくとも 1970 年代からML、CLU、Adaなどの高級言語に存在しており、その後、BETA、C++、D、Eiffel、Java、および現在は廃止されたDECのTrellis-Owlを含む多くのオブジェクトベース言語およびオブジェクト指向言語に採用されました。

ジェネリシティは、さまざまなプログラミング言語で実装およびサポート方法が異なります。また、「ジェネリック」という用語も、さまざまなプログラミング コンテキストでさまざまな意味で使用されています。たとえば、Forthでは、コンパイラはコンパイル中にコードを実行でき、新しいコンパイラ キーワードとそれらのワードの新しい実装をオンザフライで作成できます。コンパイラの動作を公開するワードはほとんどないため、ジェネリシティ機能が自然に提供されますが、ほとんどの Forth テキストではそのようには呼ばれていません。同様に、動的型付け言語、特にインタープリタ型言語では、関数への値の受け渡しと値の割り当ての両方が型に依存しないため、デフォルトでジェネリシティが提供されることが多く、このような動作は抽象化やコードの簡潔さのためによく使用されますが、これは言語で採用されている動的型付けシステムの直接的な結果であるため、通常はジェネリシティとは呼ばれません。 ^{[要出典]この用語は}関数型プログラミング、特にHaskellのような言語で使用されています。これらの言語では、型は常にパラメトリックで、それらの型の実際のコードはジェネリックである構造型システムが使用されます。これらの使用法は、コードの節約と抽象化のレンダリングという同様の目的を果たします。

配列と構造体は、定義済みのジェネリック型と見なすことができます。配列または構造体型を使用するたびに、新しい具体的な型がインスタンス化されるか、以前にインスタンス化された型が再利用されます。配列要素型と構造体要素型は、対応するジェネリック型をインスタンス化するために使用されるパラメーター化された型です。これらはすべて通常、コンパイラに組み込まれており、構文は他のジェネリック構造とは異なります。一部の拡張可能なプログラミング言語では、組み込みジェネリック型とユーザー定義ジェネリック型を統合しようとしています。

プログラミング言語におけるジェネリック性メカニズムの広範な調査は以下のとおりです。ジェネリックプログラミングにおけるメカニズムの適合性を比較した具体的な調査については、^{[17]を参照してください。}

静的型付け言語でコンテナ クラスを作成する場合、各データ型のコードが実質的に同一である場合は特に、含まれる各データ型に対して特定の実装を記述するのは不便です。たとえば、C++ では、クラス テンプレートを定義することでこのコードの重複を回避できます。

template < typename T > class List { // クラスの内容。}; 
  
  


リスト<動物> list_of_animals ;リスト<車> list_of_cars ; 
 

上記は、Tリストの作成時に指定された型のためのプレースホルダーです。これらの「T 型のコンテナ」は、一般にテンプレートと呼ばれ、サブタイプやシグネチャなどの特定の契約が保持されている限り、クラスを異なるデータ型で再利用できます。この汎用性メカニズムを包含多態性と混同しないでください。包含多態性とは、交換可能なサブクラスのアルゴリズム的使用法です。たとえば、 型のオブジェクトのリストには、Moving_Object型Animalと型のオブジェクトが含まれますCar。テンプレートは、次の例のように、型に依存しない関数にも使用できますSwap。

// "&" は参照
テンプレートを表します< typename T > void Swap ( T & a , T & b ) { // 同様ですが、より安全で潜在的に高速な関数が // 標準ライブラリ ヘッダーに定義されています <utility> T temp = b ; b = a ; a = temp ; } 
      
                        
     
    
    


std :: string world = "World!" ; std :: string hello = "Hello, " ; Swap ( world , hello ); std :: cout << world << hello << '\ n ' ; // 出力は "Hello, World!" です。   
   
 
        

template上記で使用したC++構造は、プログラマーや言語設計者の間でその概念を普及させ、多くのジェネリック プログラミング イディオムをサポートするジェネリック構造として広く引用されています^{[引用が必要]}。D 言語も、C++ の例に基づいて、簡略化された構文で完全にジェネリック対応のテンプレートを提供しています。Java 言語は、Java Platform, Standard Edition (J2SE) 5.0 の導入以来、C++ に基づいた構文のジェネリック機能を提供してきました。

C# 2.0、Oxygene 1.5 (旧 Chrome)、およびVisual Basic (.NET) 2005 には、Microsoft .NET Frameworkバージョン 2.0 以降に存在するジェネリックのサポートを活用する構造があります。

Ada は1977 ～ 1980 年に初めて設計されて以来、ジェネリックを採用しています。標準ライブラリは、ジェネリックを使用して多くのサービスを提供します。Ada 2005 では、C++ の標準テンプレート ライブラリにヒントを得た包括的なジェネリック コンテナ ライブラリが標準ライブラリに追加されています。

ジェネリックユニットとは、1つ以上のジェネリック形式パラメータを取るパッケージまたはサブプログラムである。^[18]

ジェネリック形式パラメータは、値、変数、定数、型、サブプログラム、または別の指定されたジェネリック ユニットのインスタンスです。ジェネリック形式型の場合、構文は離散型、浮動小数点型、固定小数点型、アクセス (ポインタ) 型などを区別します。一部の形式パラメータには既定値を設定できます。

ジェネリック ユニットをインスタンス化するには、プログラマーは各形式ユニットの実際のパラメーターを渡します。ジェネリック インスタンスは、他のユニットと同じように動作します。たとえばループ内で、 実行時にジェネリック ユニットをインスタンス化することができます。

汎用パッケージの仕様:

 generic 
    Max_Size  :  Natural ;  -- ジェネリックな仮値
    type  Element_Type は private ;  -- ジェネリックな仮型; 制限のない任意の型を受け入れます
 package  Stacks は 型Size_Typeで、
    範囲は0 .. Max_Sizeです。型Stack は制限付きprivateです。procedure Create ( S : out Stack ; Initial_Size : in Size_Type := Max_Size ); procedure Push ( Into : in out Stack ; Element : in Element_Type ); procedure Pop ( From : in out Stack ; Element : out Element_Type ); Overflow : exception ; Underflow : exception ; private subtype Index_TypeはSize_Typeで、範囲は1 .. Max_Sizeです。type VectorはElement_Typeの配列( Index_Type範囲< >)です。type Stack ( Allocated_Size : Size_Type := 0 )はレコードTop : Index_Type ; Storage : Vector ( 1 .. Allocated_Size ); end record ;スタックを終了します。      
        
        
                          
            
            
      
      
 
           
            
           
         
            
    
  

汎用パッケージのインスタンス化:

 type  Bookmark_Type  is  new  Natural ; 
 -- 編集中のテキスト文書内の場所を記録します

 パッケージ Bookmark_Stacks は新しい Stacks  ( Max_Size  => 20 、
                                        Element_Type  => Bookmark_Type ); 
 -- ユーザーがドキュメント内の記録された場所間を移動できるようにします

汎用パッケージのインスタンスを使用する:

 タイプ Document_Type はレコードです 。コンテンツ: Ada.Strings.Unbounded.Unbounded_String ;ブックマーク: Bookmark_Stacks.Stack ;レコードの終了;​​​​
      
      
 

 procedure  Edit  ( Document_Name  : in  String )  is 
   Document  :  Document_Type ; 
 begin 
   -- ブックマークのスタックを初期化します: 
   Bookmark_Stacks . Create  ( S  =>  Document . Bookmarks ,  Initial_Size  =>  10 ); 
   -- 次に、ファイル Document_Name を開いて読み取ります... 
 end  Edit ;

言語構文により、ジェネリック形式パラメータの制約を正確に指定できます。たとえば、ジェネリック形式型が実際の型としてモジュラー型のみを受け入れるように指定できます。また、ジェネリック形式パラメータ間の制約を表現することもできます。たとえば、次のようになります。

 ジェネリック
    型 Index_Type は (<>);  -- 離散型である必要があります
    型 Element_Type は プライベートです;  -- 任意の制限のない型にすることができます
    型 Array_Typeは Element_Typeの配列( Index_Type範囲<>)です ;     

この例では、Array_Type は Index_Type と Element_Type の両方によって制約されます。ユニットをインスタンス化する場合、プログラマはこれらの制約を満たす実際の配列型を渡す必要があります。

このきめ細かい制御の欠点は、構文が複雑になることですが、すべてのジェネリックの形式パラメータが仕様で完全に定義されているため、コンパイラはジェネリックの本体を参照せずにジェネリックをインスタンス化できます。

C++ とは異なり、Ada では特殊なジェネリック インスタンスは許可されず、すべてのジェネリックを明示的にインスタンス化する必要があります。これらのルールにはいくつかの結果があります。

• コンパイラは共有ジェネリックを実装できます。ジェネリック ユニットのオブジェクト コードは、すべてのインスタンス間で共有できます (もちろん、プログラマがサブプログラムのインライン化を要求しない限り)。さらに次のような結果になります。
  • コードが肥大化する可能性はありません (コードが肥大化することは C++ ではよくあることであり、以下で説明するように特別な注意が必要です)。
  • 新しいインスタンスには新しいオブジェクト コードが必要ないため、実行時およびコンパイル時にジェネリックをインスタンス化できます。
  • ジェネリック形式オブジェクトに対応する実際のオブジェクトは、ジェネリック内では常に非静的であると見なされます。詳細と結果については、Wikibook のジェネリック形式オブジェクトを参照してください。
• ジェネリックのすべてのインスタンスがまったく同じであるため、他の人が書いたプログラムを確認して理解するのが簡単になります。考慮すべき「特別なケース」はありません。
• すべてのインスタンス化は明示的であるため、プログラムの理解を困難にする可能性のある隠れたインスタンス化はありません。
• Ada では、ジェネリック引数に対する操作は実行時に実行されるため、コンパイル時に任意の計算を行うことはできません。

C++ では、テンプレートを使用して汎用プログラミング手法を有効にします。C++ 標準ライブラリには、共通データ構造とアルゴリズムのテンプレートのフレームワークを提供する標準テンプレート ライブラリ(STL) が含まれています。C++ のテンプレートは、テンプレート メタプログラミングにも使用できます。これは、実行時ではなくコンパイル時にコードの一部を事前評価する方法です。テンプレートの特殊化を使用すると、C++ テンプレートはチューリング完全になります。

テンプレートには多くの種類がありますが、最も一般的なのは関数テンプレートとクラス テンプレートです。関数テンプレートは、インスタンス化時に提供されるパラメータ化型に基づいて通常の関数を作成するためのパターンです。たとえば、C++ 標準テンプレート ライブラリには、xまたはy のmax(x, y)うち大きい方を返す関数を作成する関数テンプレートが含まれています。 は次のように定義できます。 max()

テンプレート< typename T > T max ( T x , T y ) { return x < y ? y : x ; } 
     
         

この関数テンプレートの特殊化、つまり特定の型によるインスタンス化は、通常の関数と同じように呼び出すことができます。

std :: cout << max ( 3 , 7 ); // 7 を出力します。     

コンパイラは、 を呼び出すために使用される引数を調べmax、これが への呼び出しであると判断します。次に、パラメータ化型がmax(int, int)である関数のバージョンをインスタンス化し、次の関数と同等のものを作成します。 Tint

int max ( int x 、int y ) {戻り値 x < y ? y : x ; }     
         

これは、引数xとがy整数、文字列、または式がx < y意味を持つその他の型であるかどうかに関係なく機能しますoperator<。より具体的には、が定義されている任意の型に対して機能します。 使用可能な型のセットには共通の継承は必要ないため、ダックタイピングと非常によく似ています。 カスタム データ型を定義するプログラムでは、演算子のオーバーロードを使用して、その型の の意味を定義し<、関数テンプレートで を使用できるようにすることmax()ができます。 この孤立した例ではこれは小さな利点のように思えるかもしれませんが、STL のような包括的なライブラリのコンテキストでは、プログラマは新しいデータ型に対していくつかの演算子を定義するだけで、そのデータ型の広範な機能を取得できます。 を定義するだけで、型を標準の、、およびアルゴリズム<で使用したり、 、ヒープ、連想配列などのデータ構造内に配置したりできるようになります。 sort()stable_sort()binary_search()set

C++ テンプレートは、コンパイル時に完全に型安全です。デモンストレーションとして、標準型は演算子complexを定義しません。これは、複素数<には厳密な順序がないためです。したがって、xとyが値の場合、 はコンパイル エラーで失敗します。同様に、 に依存する他のテンプレートは、比較 (ファンクタまたは関数の形式) が提供されない限り、データに適用できません。例: 比較が提供されない限り、 A はa のキーとして使用できません。残念ながら、コンパイラは歴史的に、この種のエラーに対してやや難解で長くて役に立たないエラー メッセージを生成します。特定のオブジェクトがメソッド プロトコルに準拠していることを確認すると、この問題を軽減できます。の代わりにを使用する言語では、値をキーとして使用することもできます。 max(x, y)complex<complexcomplexmapcompare<complex

別の種類のテンプレートであるクラス テンプレートは、同じ概念をクラスに拡張します。クラス テンプレートの特殊化はクラスです。クラス テンプレートは、汎用コンテナーを作成するためによく使用されます。たとえば、STL にはリンク リストコンテナーがあります。整数のリンク リストを作成するには、 と記述しますlist<int>。文字列のリストは と表されますlist<string>。A にlistは、互換性のあるパラメーター化型で機能する一連の標準関数が関連付けられています。

C++ のテンプレートの強力な機能は、テンプレートの特殊化です。これにより、インスタンス化されるパラメータ化された型の特定の特性に基づいて、代替実装を提供できます。テンプレートの特殊化には、特定の形式の最適化を可能にすることと、コードの肥大化を軽減することという 2 つの目的があります。

たとえば、sort()テンプレート関数について考えてみましょう。このような関数が行う主なアクティビティの 1 つは、コンテナーの 2 つの位置にある値をスワップまたは交換することです。値が大きい場合 (各値を格納するのに必要なバイト数の観点から)、最初にオブジェクトへのポインターの別のリストを作成し、それらのポインターをソートしてから、最終的なソートされたシーケンスを作成する方が速いことがよくあります。ただし、値が非常に小さい場合は、必要に応じて値をその場でスワップする方が通常は高速です。さらに、パラメーター化された型がすでに何らかのポインター型である場合は、別のポインター配列を作成する必要はありません。テンプレートの特殊化により、テンプレートの作成者はさまざまな実装を記述し、使用する各実装に対してパラメーター化された型が持つ必要がある特性を指定できます。

関数テンプレートとは異なり、クラス テンプレートは部分的に特殊化できます。つまり、一部のテンプレート パラメータがわかっている場合は、クラス テンプレート コードの代替バージョンを提供できますが、その他のテンプレート パラメータは汎用のままにしておきます。これを使用すると、たとえば、パラメータ化型のコピーはコストが高いと想定した既定の実装 (プライマリ特殊化) を作成し、コピーのコストが低い型に対しては部分的特殊化を作成して、全体的な効率を高めることができます。このようなクラス テンプレートのクライアントは、コンパイラがプライマリ特殊化を使用したのか、それとも部分的特殊化を使用したのかを各ケースで知る必要はなく、その特殊化のみを使用します。クラス テンプレートは完全に特殊化することもできます。つまり、すべてのパラメータ化型がわかっている場合は、代替実装を提供できます。

関数などのテンプレートの一部の使用は、以前は関数のようなプリプロセッサマクロ( C言語の遺産)max()によって埋められていました。たとえば、次のようなマクロの実装が可能です。

#define max(a,b) ((a) < (b) ? (b) : (a))

マクロは、プログラムのコンパイル前にプリプロセッサによって展開（コピー＆ペースト）されます。テンプレートは実際の関数です。マクロは常にインラインで展開されます。コンパイラが適切と判断した場合、 テンプレートもインライン関数になることがあります。

ただし、これらの目的においては、テンプレートは一般にマクロよりも優れていると考えられています。テンプレートは型安全です。テンプレートは、副作用のあるパラメータを 2 回評価するなど、関数のようなマクロを多用するコードでよく見られるエラーの一部を回避します。おそらく最も重要なのは、テンプレートはマクロよりもはるかに大きな問題に適用できるように設計されていることです。

テンプレートの使用には、サポートされる機能、コンパイラのサポート、貧弱なエラー メッセージ (通常、C++20 より前のバージョンでは、置換の失敗はエラーではありません( SFINAE ))、およびコードの肥大化という 4 つの主な欠点があります。

1. C++ のテンプレートには多くの機能が欠けているため、実装して直接使用することが不可能な場合が多くあります。代わりに、プログラマーは複雑なトリックに頼らざるを得ず、その結果、コードが肥大化し、理解しにくくなり、保守が難しくなります。C++ 標準の現在の開発では、これらのトリックを多用し、これらのトリックに基づいて、またはこれらを意図して、テンプレートの多くの新機能を構築することで、この問題が悪化しています。
2. 多くのコンパイラは歴史的にテンプレートのサポートが不十分であったため、テンプレートを使用するとコードの移植性が多少低下する可能性があります。C++ コンパイラがC++ に対応していないリンカーで使用されている場合や、共有ライブラリの境界を越えてテンプレートを使用しようとした場合にも、サポートが不十分になる可能性があります。
3. SFINAEを使用するコードでエラーが検出されると、コンパイラは混乱を招き、長く、時には役に立たないエラーメッセージを生成することがあります。^[19]これにより、テンプレートの開発が困難になる可能性があります。
4. 最後に、テンプレートを使用すると、コンパイラは、テンプレート化されたクラスまたは関数で使用されるすべての型パラメータに対して、その個別のインスタンスを生成する必要があります。(C++ の型はすべて同じサイズではなく、データ フィールドのサイズはクラスの動作に重要であるため、これが必要です。) そのため、テンプレートを無差別に使用すると、コードが肥大化し、実行可能ファイルが過度に大きくなる可能性があります。ただし、テンプレートの特殊化と派生を慎重に使用すると、場合によってはこのようなコード肥大化を大幅に削減できます。

   では、テンプレートの使用によってコードが複製されるという問題を軽減するために派生を使用できるでしょうか。これには、通常のクラスからテンプレートを派生させるという作業が含まれます。この手法は、実際の使用においてコードの肥大化を抑制するのに効果的であることが証明されています。このような手法を使用しない人は、複製されたコードによって、中程度のサイズのプログラムでも数メガバイトのコード領域が必要になることに気付きました。

   — ビャーネ・ストロウストルップ、C++の設計と進化、1994年^[20]

5. テンプレート化されたクラスまたは関数では、テンプレート クラスの明示的な特殊化が必要になる場合があります。その場合、テンプレート クラスで使用される特定のテンプレート パラメータに合わせてクラス全体を書き直す必要があります。

テンプレートによって生成される追加のインスタンス化により、一部のデバッガーがテンプレートを正常に操作できなくなることもあります。たとえば、ソース ファイルからテンプレート内にデバッグ ブレークポイントを設定すると、必要な実際のインスタンス化でブレークポイントが設定されなかったり、テンプレートがインスタンス化されるすべての場所でブレークポイントが設定されたりする可能性があります。

また、テンプレートの実装ソースコードは、それを使用する翻訳単位 (ソースファイル) で完全に利用可能 (たとえば、ヘッダーに含まれる) である必要があります。標準ライブラリの多くを含むテンプレートは、ヘッダーファイルに含まれていない場合はコンパイルできません。 (これは、テンプレート化されていないコードとは対照的です。テンプレート化されていないコードはバイナリにコンパイルされ、それを使用するコードに宣言ヘッダーファイルのみを提供します。) これは、実装コードが公開されることによって不利になる可能性があり、一部の抽象化が削除され、クローズドソースプロジェクトでの使用が制限される可能性があります。^{[引用が必要]}

D言語は、C++ の設計に基づいたテンプレートをサポートしています。ほとんどの C++ テンプレートの慣用句は変更なしで D でも動作しますが、D ではいくつかの機能が追加されています。

• D のテンプレート パラメータは、(C++20 より前の C++ のように) 型とプリミティブ値だけに制限されるのではなく、任意のコンパイル時の値 (文字列や構造体リテラルなど) や、他のテンプレートやテンプレートのインスタンス化を含む任意の識別子へのエイリアスも許可されます。
• テンプレート制約とstatic ifステートメントは、それぞれ C++ のC++ 概念との代替手段を提供しますif constexpr。
• このis(...)式により、コンパイル時にオブジェクトの特性を確認するための推測的なインスタンス化が可能になります。
• キーワードautoと式により、変数宣言と関数の戻り値の型推論typeofが可能になり、「ヴォルデモート型」（グローバル名を持たない型）が可能になります。^[21]

D のテンプレートは C++ とは異なる構文を使用します。C++ のテンプレート パラメータは山括弧 ( Template<param1, param2>) で囲まれますが、D では感嘆符と括弧 を使用します。これにより、比較演算子の曖昧さによるC++ の解析の困難をTemplate!(param1, param2)回避できます。パラメータが 1 つしかない場合は、括弧を省略できます。

従来、D は上記の機能を組み合わせて、特性ベースのジェネリック プログラミングを使用してコンパイル時のポリモーフィズムを提供します。たとえば、入力範囲は、次のように定義されるによって実行されるチェックを満たす任意の型として定義されますisInputRange。

template isInputRange ( R ) { enum bool isInputRange = is ( typeof ( ( inout int = 0 ) { R r = R . init ; // 範囲オブジェクトを定義できますif ( r . empty ) {} // 空かどうかをテストできますr . popFront (); // popFront() を呼び出すことができますauto h = r . front ; // 範囲の先頭を取得できます})); } 

        
       
    
                
             
             
            
    

入力範囲のみを受け入れる関数は、テンプレート制約で上記のテンプレートを使用できます。

auto fun ( Range )( Range range ) if ( isInputRange ! Range ) { // ... }  
     

    

テンプレート メタプログラミングに加えて、D はコンパイル時のコード生成を可能にするいくつかの機能も提供します。

• このimport式を使用すると、ディスクからファイルを読み取り、その内容を文字列式として使用することができます。
• コンパイル時のリフレクションにより、コンパイル中に宣言とそのメンバーを列挙および検査できます。
• ユーザー定義属性を使用すると、ユーザーは宣言に任意の識別子を添付することができ、コンパイル時のリフレクションを使用して列挙することができます。
• コンパイル時関数実行(CTFE) を使用すると、コンパイル時に D のサブセット (安全な操作に制限) を解釈できます。
• 文字列ミックスインを使用すると、文字列式の内容をプログラムの一部となる D コードとして評価およびコンパイルできます。

上記を組み合わせることで、既存の宣言に基づいてコードを生成できます。たとえば、D シリアル化フレームワークは、型のメンバーを列挙し、シリアル化された型ごとにシリアル化とデシリアル化を実行するための特殊な関数を生成できます。ユーザー定義属性は、シリアル化ルールをさらに示すことができます。

式importとコンパイル時の関数実行により、ドメイン固有言語を効率的に実装することもできます。たとえば、HTML テンプレートを含む文字列を受け取り、同等の D ソース コードを返す関数がある場合、次のように使用できます。

// example.htt の内容を文字列マニフェスト定数としてインポートします。
enum htmlTemplate = import ( "example.htt" );   

// HTML テンプレートを D コードにトランスパイルします。
enum htmlDCode = htmlTemplateToD ( htmlTemplate );   

// htmlDCode の内容を D コードとして貼り付けます。
mixin ( htmlDCode );

ジェネリッククラスは、Eiffelのオリジナルのメソッドと言語設計以来、 Eiffelの一部となっています。Eiffelの基礎出版物^{[22] [23]では、ジェネリッククラスの作成と使用を説明するために}「ジェネリシティ」という用語が使用されています。

ジェネリッククラスは、クラス名と1つ以上の正式なジェネリックパラメータのリストで宣言されます。次のコードでは、クラスにはLIST1つの正式なジェネリックパラメータがあります。G

class 
LIST [ G ] ... feature -- アクセスitem : G -- 現在カーソルが指している項目... feature -- 要素の変更put ( new_item : G ) -- リストの最後に `new_item' を追加します...     
            
   
     
            
            
   
      
            
            

正式なジェネリック パラメータは、ジェネリック クラスの宣言時に指定される任意のクラス名のプレースホルダです。これは、以下の2 つのジェネリック派生ACCOUNTで示されます。ここで、 と はDEPOSIT他のクラス名です。ACCOUNTと は、実際の使用時に を置き換える実際のクラス名を提供するため、実際のジェネリック パラメータDEPOSITと見なされます。G

    list_of_accounts : LIST [ ACCOUNT ] -- アカウントリスト  
            

    list_of_deposits : LIST [ DEPOSIT ] -- 預金リスト  
            

Eiffel 型システムでは、クラスはクラスと見なされますが、型とは見なされません。ただし、などLIST [G]のジェネリック派生は型と見なされます。 LIST [G]LIST [ACCOUNT]

上記のリスト クラスの場合、 を置き換える実際のジェネリック パラメータはG、他の任意の使用可能なクラスにすることができます。有効な実際のジェネリック パラメータを選択できるクラスのセットを制限するには、ジェネリック制約を指定します。以下のクラスの宣言ではSORTED_LIST、ジェネリック制約によって、有効な実際のジェネリック パラメータはクラス から継承するクラスになることが規定されています。ジェネリック制約によって、 の要素が実際に並べ替えられる COMPARABLEことが保証されます。SORTED_LIST

クラス
SORTED_LIST [ G -> COMPARABLE ]       

ジェネリック、または「T 型のコンテナ」のサポートは、2004 年に J2SE 5.0 の一部としてJava プログラミング言語に追加されました。Java では、ジェネリックはコンパイル時に型の正しさのみがチェックされます。ジェネリックの型情報は、古いJVM実装との互換性を維持するために、型消去と呼ばれるプロセスによって削除され、実行時に使用できなくなります。^[24]たとえば、 a は生の型 に変換されます。コンパイラは、リストから要素を取得するときに型キャストを挿入して要素を型に変換しますが、C++ テンプレートなどの他の実装と比較してパフォーマンスが低下します。 List<String>ListString

ジェネリックは、1999 年に開始された Microsoft Research の研究プロトタイプに基づいて、2005 年 11 月に.NET Framework 2.0の一部として追加されました。 ^{[25] Java のジェネリックに似ていますが、.NET ジェネリックは}型の消去を適用しません^{[26] : 208–209}が、具体化を使用してランタイムでジェネリックをファーストクラスのメカニズムとして実装します。この設計上の選択により、ジェネリック型を保存したリフレクションを許可したり、消去の制限の一部 (ジェネリック配列を作成できないなど) を緩和したりするなど、追加機能が提供されます。^{[27] [28]これは、ランタイム}キャストや通常はコストのかかるボックス化変換によるパフォーマンスの低下がないことも意味します。プリミティブ型と値型をジェネリック引数として使用すると、特殊な実装が得られ、効率的なジェネリックコレクションとメソッドが可能になります。C++ や Java と同様に、Dictionary<string、List<int>> などのネストされたジェネリック型は有効な型ですが、コード分析設計ルールではメンバーシグネチャには使用しないことが推奨されています。^[29]

where.NETでは、ジェネリック型を値型、クラス、コンストラクタ、インタフェースの実装に制限するなど、キーワードを使用して6種類のジェネリック型制約を許可しています。 ^[30]以下はインタフェース制約の例です。

システムの使用; 

クラスサンプル 
{
    静的voidメイン()  
    {
        int []配列= { 0 , 1 , 2 , 3 };        
        MakeAtLeast < int > ( array , 2 ); // 配列を { 2, 2, 2, 3 } に変更します  
        foreach ( int i in配列)    
            Console . WriteLine ( i ); // 結果を出力します。 
        コンソール.ReadKey ( true ) ;
    }

    static void MakeAtLeast < T > ( T [] list , T lowest )ただしT : IComparable < T >         
    {
        for ( int i = 0 ; i <リスト.長さ; i ++ )        
            if (リスト[ i ]. CompareTo (最低) < 0 )   
                リスト[ i ] =最低;  
    }
}

メソッドMakeAtLeast()は、ジェネリック型 の要素を持つ配列に対する操作を許可します。 メソッドの型制約は、メソッドがジェネリック インターフェイスを実装するT任意の型に適用可能であることを示します。 これにより、型が比較をサポートしていない場合にメソッドが呼び出されると、コンパイル時エラーが発生します。 インターフェイスはジェネリック メソッド を提供します。 TIComparable<T>CompareTo(T)

上記のメソッドは、ジェネリック型を使用せずに、単に非ジェネリックArray型を使用して記述することもできます。ただし、配列は反変であるため、キャストは型安全ではなく、コンパイラはジェネリック型を使用した場合にキャッチされる可能性のある特定のエラーを見つけることができません。さらに、メソッドはobject代わりに s として配列項目にアクセスする必要があり、 2 つの要素を比較するためにキャストが必要になります。(このような型のような値型の場合、ボックス化int変換が必要ですが、これは標準のコレクション クラスで行われるように、 クラスを 使用して回避できます。)Comparer<T>

汎用 .NET クラスの静的メンバーの注目すべき動作は、実行時の型ごとに静的メンバーがインスタンス化されることです (以下の例を参照)。

    // ジェネリッククラス
public class GenTest < T > { // 静的変数 - リフレクションで各型に対して作成されますstatic CountedInstances OnePerType = new CountedInstances ();      
    
        
             

        // データメンバー
private T _t ;          

        // シンプルなコンストラクタ
public GenTest ( T t ) { _t = t ; } }          
        
              
        
    

    // クラス
public class CountedInstances { // 静的変数 - インスタンスごとに 1 回増加しますpublic static int Counter ;      
    
        
           

        // シンプルなコンストラクター
public CountedInstances () { // オブジェクトのインスタンス化中にカウンターを 1 つ増やすCountedInstances . Counter ++ ; } }         
        
            
            
        
    

// メイン コードのエントリ ポイント
// 実行の終了時に、CountedInstances.Counter = 2 
GenTest < int > g1 = new GenTest < int > ( 1 ); GenTest < int > g11 = new GenTest < int > ( 11 ); GenTest < int > g111 = new GenTest < int > ( 111 ); GenTest < double > g2 = new GenTest < double > ( 1.0 );    
    
    
    

Pascalの場合、ジェネリックは 2006 年に Free Pascal 実装で初めて実装されました。

Object Pascal方言Delphi は、 CodeGearによる 2007 Delphi 11 リリースでジェネリックを獲得しました。当初は .NET コンパイラ (その後廃止) でのみサポートされていましたが、2009 Delphi 12 リリースでネイティブ コードに追加されました。Delphi ジェネリックのセマンティクスと機能は、主に .NET 2.0 のジェネリックをモデルにしていますが、実装は必然的に大きく異なります。以下は、上記の最初の C# の例をほぼそのまま翻訳したものです。

プログラムサンプル; 

{$APPTYPE コンソール}


Generics . Defaultsを使用します。// IComparer<> の場合   

type 
TUtils = classクラスプロシージャMakeAtLeast < T > ( Arr : TArray < T >; const Lowest : T ; Comparer : IComparer < T > ) ;オーバーロード;クラスプロシージャMakeAtLeast < T > ( Arr : TArray < T >; const Lowest : T ) ;オーバーロード;終了;    
          
        
           
  

クラスプロシージャTUtils.MakeAtLeast < T > ( Arr : TArray < T >; const Lowest : T ; Comparer : IComparer < T > ) ; var I : Integer ; begin if Comparer = nil then Comparer : = TComparer < T > . Default ; for I : = Low ( Arr ) to High ( Arr ) do if Comparer.Compare ( Arr [ I ] , Lowest ) < 0 then Arr [ I ] : = Lowest ; end ;      
   

   

         
        
         
        


クラスプロシージャTUtils.MakeAtLeast < T > ( Arr : TArray < T > ; const Lowest : T ) ; begin MakeAtLeast < T > ( Arr , Lowest , nil ) ; end ;​      

    


var 
Ints : TArray < Integer > ; Value : Integer ; begin Ints : = TArray < Integer > .Create ( 0 , 1 , 2 , 3 ) ; TUtils.MakeAtLeast < Integer > ( Ints , 2 ) ; for Value in Ints do WriteLn ( Value ) ; ReadLn ; end .   
   

       
   
      
    
  

C# と同様に、メソッドと型全体には 1 つ以上の型パラメータを設定できます。この例では、TArray はジェネリック型 (言語によって定義) で、MakeAtLeast はジェネリック メソッドです。使用可能な制約は、C# で使用可能な制約と非常によく似ています。つまり、任意の値型、任意のクラス、特定のクラスまたはインターフェイス、およびパラメータなしのコンストラクターを持つクラスです。複数の制約は、加法的結合として機能します。

Free Pascal は、 2006 年にバージョン 2.2.0でジェネリックを実装しました。これは Delphi より前のことで、構文とセマンティクスが異なっていました。ただし、FPC バージョン 2.6.0 以降では、言語モードを使用する場合に Delphi スタイルの構文が使用できます{$mode Delphi}。したがって、Free Pascal コードはどちらのスタイルでもジェネリックをサポートします。

Delphi と Free Pascal の例:

// Delphi スタイルの
ユニットA ; 

{$ifdef fpc} 
{$mode delphi} {$endif}  


インタフェース

型
TGenericClass < T > =クラス関数Foo ( const AValue : T ) : T ;終了;    
        
  

実装

関数TGenericClass < T >。Foo ( const AValue : T ) : T ;結果: = AValue + AValue ;終わり;    

      


終わり。

// Free Pascal の ObjFPC スタイル
ユニットB ; 

{$ifdef fpc} 
{$mode objfpc} {$endif}  


インタフェース

型
ジェネリックTGenericClass < T > =クラス関数Foo ( const AValue : T ) : T ;終了;     
        
  

実装

関数TGenericClass 。Foo ( const AValue : T ) : T ;結果: = AValue + AValue ;終わり;    

      


終わり。

// 使用例、Delphi スタイルの
プログラムTestGenDelphi ; 

{$ifdef fpc} 
{$mode delphi} {$endif}  



A 、B を使用します。  

var 
GC1 : A.TGenericClass <Integer> ; GC2 : B.TGenericClass <String> ; begin GC1 : = A.TGenericClass <Integer> .Create ; GC2 : = B.TGenericClass <String> .Create ; WriteLn ( GC1.Foo ( 100 ) ) ; // 200 WriteLn ( GC2.Foo ( ' hello ' ) ) ; // hellohello GC1.Free ; GC2.Free ; end .​​​​​​​​​​​​​​   
   

    
    
   
   
  
  


// 使用例、ObjFPC スタイルの
プログラムTestGenDelphi ; 

{$ifdef fpc} 
{$mode objfpc} {$endif}  



A 、B を使用します。  

// ObjFPC で必須
type 
TAGenericClassInt = specialize A . TGenericClass < Integer >; TBGenericClassString = specialize B . TGenericClass < String >; var GC1 : TAGenericClassInt ; GC2 : TBGenericClassString ; begin GC1 := TAGenericClassInt . Create ; GC2 := TBGenericClassString . Create ; WriteLn ( GC1 . Foo ( 100 )) ; // 200 WriteLn ( GC2 . Foo ( 'hello' )) ; // hellohello GC1 . Free ; GC2 . Free ; end .     
     

   
   

    
    
   
   
  
  

Haskellの型クラスメカニズムは、ジェネリック プログラミングをサポートします。Haskell の定義済み型クラスのうち 6 つ (等価性を比較できる型 と、値を文字列としてレンダリングできる型 を含む)には、派生インスタンスをサポートするという特別なプロパティがあります。つまり、新しい型を定義するプログラマは、クラス インスタンスを宣言するときに通常必要となるクラス メソッドの実装を提供せずに、この型がこれらの特別な型クラスの 1 つのインスタンスであると宣言できます。必要なメソッドはすべて、型の構造に基づいて「派生」、つまり自動的に構築されます。たとえば、次のバイナリ ツリーの型の宣言では、クラスとのインスタンスであると宣言されています。 EqShowEqShow

データBinTree a = Leaf a | Node ( BinTree a ) a ( BinTree a )導出( Eq , Show )            
        

これにより、フォーム自体がそれらの操作をサポートし ていれば、フォームの任意の型に対して等価関数 ( ==) と文字列表現関数 ( ) が自動的に定義されます。showBinTree TT

と の派生インスタンスのサポートによりEq、Showそれらのメソッドと は、パラメトリック多態関数==とshowは質的に異なる方法でジェネリックになります。これらの「関数」(より正確には、型インデックス付き関数のファミリ) は、さまざまな型の値に適用でき、引数の型ごとに動作が異なりますが、新しい型のサポートを追加するのにほとんど作業は必要ありません。Ralf Hinze (2004) は、特定のプログラミング手法によって、ユーザー定義の型クラスで同様の効果が得られることを示しました。他の研究者は、Haskell と Haskell の拡張機能のコンテキストで、これや他の種類のジェネリック性へのアプローチを提案しています (以下で説明します)。

PolyP は、 Haskellへの最初の汎用プログラミング言語拡張でした。PolyP では、汎用関数はpolytypicと呼ばれます。この言語では、正規データ型のパターン関数の構造に対する構造的帰納法によって、このような polytypic 関数を定義できる特別な構造が導入されています。PolyP の正規データ型は、Haskell データ型のサブセットです。正規データ型 t は種類が * → *でなければならず、定義でa が正式な型引数である場合、 tへのすべての再帰呼び出しは形式taでなければなりません。これらの制限により、再帰呼び出しが異なる形式になる、より種類が多いデータ型やネストされたデータ型は除外されます。PolyP の flatten 関数を例として示します。

   flatten ::通常d => d a -> [ a ] flatten = cata fl        
      

   多型fl :: f a [ a ] -> [ a ] case f of g + h -> Either fl fl g * h -> \ ( x , y ) -> fl x ++ fl y () -> \ x -> [] Par -> \ x -> [ x ] Rec -> \ x -> x d @ g -> concat . flatten . pmap fl Con t -> \ x -> []       
       
           
               
           
           
           
              
            

   cata :: Regular d => ( FunctorOf d a b -> b ) -> d a -> b