sjablonen in C++bewerken

hoofdartikel: Template (C++)

C++ gebruikt sjablonen om generieke programmeertechnieken in te schakelen. De standaardbibliotheek C++ bevat de Standaardsjabloonbibliotheek of STL die een raamwerk van sjablonen biedt voor gemeenschappelijke datastructuren en algoritmen. Templates in C++ kunnen ook worden gebruikt voor template metaprogrammering, wat een manier is om een deel van de code vooraf te evalueren tijdens het compileren in plaats van tijdens het uitvoeren. Met behulp van template specialisatie, C++ Templates worden beschouwd als Turing compleet.,

Technical overviewEdit

Er zijn twee soorten sjablonen: functiesjablonen en klassensjablonen. Een functiesjabloon is een patroon voor het creëren van gewone functies die gebaseerd zijn op de parametriseertypes die worden geleverd wanneer ze worden geïnstalleerd. De standaard sjabloonbibliotheek C++ bevat bijvoorbeeld de functiesjabloon max (x, y) die functies creëert die x of y retourneren, afhankelijk van wat groter is., max() kan als volgt worden gedefinieerd:

template <typename T>T max(T x, T y) { return x < y ? y : x;}

specialisaties van dit functiesjabloon, instantiaties met specifieke types, kunnen net als een gewone functie worden aangeroepen:

std::cout << max(3, 7); // Outputs 7.

de compiler onderzoekt de argumenten die gebruikt worden om max aan te roepen en bepalen dat dit een aanroep is naar max(int, int)., Het instantieert vervolgens een versie van de functie waar het parametriseertype T int is, waardoor het equivalent van de volgende functie is:

int max(int x, int y) { return x < y ? y : x;}

Dit werkt of de argumenten x en y gehele getallen, tekenreeksen of elk ander type zijn waarvoor de uitdrukking x < y zinvol is, of meer specifiek, voor elk type waarvoor operator< is gedefinieerd. Gemeenschappelijke overerving is niet nodig voor de reeks types die kunnen worden gebruikt, en dus is het zeer vergelijkbaar met eend typen., Een programma dat een aangepast gegevenstype definieert kan operator overloading gebruiken om de Betekenis van < voor dat type te definiëren, waardoor het gebruik met de max() functie template wordt toegestaan. Hoewel dit misschien een klein voordeel lijkt in dit geïsoleerde voorbeeld, stelt het in de context van een uitgebreide bibliotheek zoals de STL de programmeur in staat om uitgebreide functionaliteit te krijgen voor een nieuw gegevenstype, gewoon door er een paar operators voor te definiëren., Alleen het definiëren van < maakt het mogelijk om een type te gebruiken met de standaard sort(), stable_sort(), en binary_search() algoritmen of om binnen datastructuren te plaatsen zoals sets, heaps en associatieve arrays.

c++ sjablonen zijn volledig type veilig tijdens het compileren. Als voorbeeld, het standaard type complex definieert niet de< operator, omdat er geen strikte volgorde is voor complexe getallen. Daarom zal max(x, y) falen met een compileerfout, als x en y complexe waarden zijn., Ook andere sjablonen die afhankelijk zijn van < kunnen niet worden toegepast op complexe gegevens, tenzij een vergelijking (in de vorm van een functor of functie) wordt gegeven. Bijvoorbeeld: een complex kan niet worden gebruikt als sleutel voor een kaart, tenzij een vergelijking wordt verstrekt. Helaas genereren compilers historisch enigszins esoterische, lange en nutteloze foutmeldingen voor dit soort fouten. Ervoor zorgen dat een bepaald object zich aan een methodeprotocol houdt, kan dit probleem verlichten. Talen die compare gebruiken in plaats van < kunnen ook complexe waarden als sleutels gebruiken.,

de tweede soort sjabloon, een klassensjabloon, breidt hetzelfde concept uit tot klassen. Een klasse template specialisatie is een klasse. Class templates worden vaak gebruikt om generieke containers te maken. Bijvoorbeeld, de STL heeft een gekoppelde lijst container. Om een gekoppelde lijst van gehele getallen te maken, schrijft men lijst<int>. Een lijst met tekenreeksen wordt aangeduid als list<string>. Een lijst heeft een set van standaard functies die ermee verbonden zijn, die werken voor alle compatibele parametriseertypes.,

Template specializationEdit

een krachtig kenmerk van C++’s templates is template specialisatie. Hierdoor kunnen alternatieve implementaties worden verstrekt op basis van bepaalde kenmerken van het geparametreerde type dat wordt geïnstalleerd. Template specialisatie heeft twee doelen: het toestaan van bepaalde vormen van optimalisatie, en het verminderen van code bloat.

bijvoorbeeld, overweeg een sort () template functie. Een van de primaire activiteiten die een dergelijke functie doet is om de waarden in twee van de posities van de container te ruilen of te ruilen., Als de waarden groot zijn (in termen van het aantal bytes dat nodig is om elk van hen op te slaan), dan is het vaak sneller om eerst een aparte lijst met pointers naar de objecten te bouwen, die pointers te sorteren, en vervolgens de uiteindelijke gesorteerde reeks te bouwen. Als de waarden vrij klein zijn, is het meestal het snelst om de waarden op hun plaats te verwisselen als dat nodig is. Verder, als het geparametreerde type al van een pointer-type is, dan is het niet nodig om een aparte pointer array te bouwen., Template specialisatie staat de template maker toe om verschillende implementaties te schrijven en om de kenmerken te specificeren die het geparametreerde type (s) moet hebben voor elke implementatie die gebruikt moet worden.

In tegenstelling tot functiesjablonen, kunnen klassensjablonen gedeeltelijk gespecialiseerd zijn. Dat betekent dat een alternatieve versie van de class template code kan worden verstrekt wanneer sommige van de template parameters bekend zijn, terwijl andere template parameters generiek blijven., Dit kan bijvoorbeeld worden gebruikt om een standaardimplementatie (de primaire specialisatie) te maken die ervan uitgaat dat het kopiëren van een parametriseertype duur is en vervolgens gedeeltelijke specialisaties te maken voor typen die goedkoop zijn om te kopiëren, waardoor de algehele efficiëntie wordt verhoogd. Klanten van een dergelijke klasse template gewoon gebruik maken van specialisaties van het zonder te weten of de compiler gebruikt de primaire specialisatie of een gedeeltelijke specialisatie in elk geval., Class templates kunnen ook volledig gespecialiseerd zijn, wat betekent dat een alternatieve implementatie kan worden verstrekt wanneer alle parametriseertypen bekend zijn.

voor-en nadelen edit

sommige toepassingen van sjablonen, zoals de max() functie, werden eerder gevuld met functie-achtige preprocessor macro ‘ s (een erfenis van de programmeertaal C). Hier is bijvoorbeeld een mogelijke Max() macro:

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

macro ‘ s worden uitgebreid met preprocessor, voordat de compilatie correct is; sjablonen worden uitgebreid tijdens het compileren., Macro ‘ s worden altijd inline uitgebreid; sjablonen kunnen ook worden uitgebreid als inline functies wanneer de compiler dit passend acht. Dus zowel functie-achtige macro ‘ s en functie templates hebben geen run-time overhead.

templates worden echter over het algemeen beschouwd als een verbetering ten opzichte van macro ‘ s voor deze doeleinden. Sjablonen zijn type-veilig. Sjablonen vermijden enkele van de veel voorkomende fouten in code die zwaar gebruik maakt van functie-achtige macro ‘ s, zoals het evalueren van parameters met bijwerkingen twee keer. Misschien wel het belangrijkste, templates zijn ontworpen om van toepassing te zijn op veel grotere problemen dan macro ‘ s.,

Er zijn vier primaire nadelen aan het gebruik van sjablonen: ondersteunde functies, compilerondersteuning, slechte foutmeldingen en code bloat:

  1. sjablonen in C++ missen veel functies, waardoor het vaak onmogelijk is ze te implementeren en op een eenvoudige manier te gebruiken. In plaats daarvan moeten programmeurs vertrouwen op ingewikkelde trucs die leiden tot opgeblazen, moeilijk te begrijpen en moeilijk te onderhouden code. De huidige ontwikkelingen in de C++ normen verergeren dit probleem door zwaar gebruik te maken van deze trucs en het bouwen van een heleboel nieuwe functies voor sjablonen op hen of met hen in gedachten.,
  2. veel compilers hebben in het verleden slechte ondersteuning voor sjablonen, dus het gebruik van sjablonen kan code iets minder draagbaar maken. Ondersteuning kan ook slecht zijn wanneer een C++ – compiler wordt gebruikt met een linker die niet C++-bewust is, of wanneer wordt geprobeerd om sjablonen te gebruiken over gedeelde bibliotheekgrenzen heen. De meeste moderne compilers hebben nu echter vrij robuuste en Standaard template ondersteuning, en de nieuwe C++ standaard, C++11, Lost deze problemen verder op.
  3. bijna alle compilers produceren verwarrende, lange of soms nutteloze foutmeldingen wanneer fouten worden gedetecteerd in code die sjablonen gebruikt., Dit kan sjablonen moeilijk maken om te ontwikkelen.
  4. ten slotte vereist het gebruik van sjablonen dat de compiler een aparte instantie van de gesjabelde klasse of functie genereert voor elke permutatie van typeparameters die ermee wordt gebruikt. (Dit is nodig omdat typen in C++ niet allemaal dezelfde grootte hebben en de grootte van gegevensvelden belangrijk zijn voor hoe klassen werken.) Dus het willekeurige gebruik van sjablonen kan leiden tot code bloat, wat resulteert in buitensporig grote uitvoerbare bestanden., Echter, verstandig gebruik van template specialisatie en afleiding kan dergelijke code bloat drastisch verminderen in sommige gevallen:

dus, kan afleiding worden gebruikt om het probleem van code gerepliceerd omdat sjablonen worden gebruikt? Dit zou inhouden dat een sjabloon wordt afgeleid uit een gewone klasse. Deze techniek bleek succesvol in het beteugelen van code bloat in echt gebruik. Mensen die geen gebruik maken van een techniek als deze hebben ontdekt dat gerepliceerde code kan kosten megabytes aan code ruimte, zelfs in matige grootte programma ‘ s.,

– Bjarne Stroustrup, the Design and Evolution of C++, 1994

de extra instantiaties gegenereerd door sjablonen kunnen er ook voor zorgen dat debuggers moeite hebben om sierlijk met sjablonen te werken. Bijvoorbeeld, het instellen van een debug breekpunt binnen een sjabloon van een bronbestand kan ofwel missen het instellen van het breekpunt in de werkelijke instantiation gewenste of kan een breekpunt in elke plaats de sjabloon wordt geïnstalleerd.,

ook, omdat de compiler macro-achtige uitbreidingen van sjablonen moet uitvoeren en verschillende instanties van hen moet genereren tijdens het compileren, moet de implementatie broncode voor de templated klasse of functie beschikbaar zijn (bijvoorbeeld opgenomen in een header) voor de code die deze gebruikt. Templated klassen of functies, waaronder een groot deel van de standaard sjabloonbibliotheek (STL), kunnen niet gecompileerd worden als ze niet zijn opgenomen in headerbestanden. (Dit is in tegenstelling tot niet-templated code, die kan worden gecompileerd naar binair, het verstrekken van alleen een declarations header bestand voor de code die het gebruikt.,) Dit kan een nadeel zijn door het blootleggen van de implementatiecode, die enkele abstracties verwijdert, en het gebruik ervan in closed-source projecten kan beperken.

sjablonen in DEdit

de programmeertaal D ondersteunt sjablonen gebaseerd op ontwerp op C++.,De meeste C++ template idiomen zullen zonder wijziging naar D overgaan, maar D voegt wat extra functionaliteit toe:

  • Template parameters in D zijn niet beperkt tot alleen types en primitieve waarden, maar staan ook willekeurige compilatie-tijd waarden toe (zoals strings en struct literals), en aliassen naar willekeurige identifiers, inclusief andere sjablonen of template instantiaties.
  • Sjabloonbeperkingen en het statisch if statement bieden een alternatief voor C++’s substitutiefout is geen error (SFINAE) mechanisme, vergelijkbaar met C++ Concepten.
  • De is (…,) expressie laat speculatieve instantiation toe om de eigenschappen van een object te verifiëren tijdens het compileren.
  • het automatische sleutelwoord en het type of expression staan type gevolgtrekking toe voor variabele declaraties en functiereturnwaarden, die op hun beurt “Voldemort types” (types die geen globale naam hebben) toestaan.

Templates in D gebruiken een andere syntaxis dan in C++: terwijl in C++ template parameters zijn verpakt in hoekige haakjes (Template<param1, param2>), gebruikt D een uitroepteken en haakjes: Template!(param1, param2).,Dit vermijdt de C++ parsing moeilijkheden als gevolg van dubbelzinnigheid met vergelijking operators.Als er maar één parameter is, kunnen de haakjes worden weggelaten.

conventioneel combineert D de bovenstaande functies om compileertijdpolymorfisme te bieden met behulp van op trait gebaseerde generieke programmering.,Bijvoorbeeld, een input bereik is gedefinieerd als een type dat voldoet aan de controles uitgevoerd door isInputRange, die als volgt gedefinieerd:

Een functie die accepteert alleen input ranges kunt dan gebruik maken van het bovenstaande sjabloon in een sjabloon beperking:

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

naast sjabloon meta-programmeren, D ook biedt verschillende functies waarmee compile-time code generatie:

  • Het importeren van meningsuiting maakt het lezen van een bestand van de schijf en het gebruik van de inhoud als een teken reeks expressie.,
  • Compile-time reflectie maakt het opsommen en inspecteren van verklaringen en hun leden tijdens de compilatie mogelijk.
  • door de gebruiker gedefinieerde attributen stellen gebruikers in staat om willekeurige identifiers aan declaraties toe te voegen, die vervolgens kunnen worden opgesomd met behulp van compilatietijdreflectie.
  • Compile-Time function Execution (CTFE) maakt het mogelijk een subset van D (beperkt tot veilige bewerkingen) te interpreteren tijdens de compilatie.
  • String mixins maken het mogelijk om de inhoud van een string expressie te evalueren en te compileren als D code die onderdeel wordt van het programma.,

door bovenstaande combinatie kan code worden gegenereerd op basis van bestaande declaraties.Bijvoorbeeld, D serialisatie frameworks kunnen een type leden opsommen en gespecialiseerde functies genereren voor elk geserialiseerd type om serialisatie en deserialisatie uit te voeren.Door de gebruiker gedefinieerde attributen kunnen verder serialisatieregels aangeven.

De functie Import expression en compileertijd maken het ook mogelijk om domeinspecifieke talen efficiënt te implementeren.,Bijvoorbeeld, gegeven een functie die een tekenreeks met een HTML-sjabloon neemt en equivalente d-broncode retourneert, is het mogelijk om deze op de volgende manier te gebruiken:

Genericiteit in EiffelEdit

Generieke klassen zijn een onderdeel van Eiffel sinds de oorspronkelijke methode en taalontwerp. De publicaties van de stichting Eiffel, gebruiken de term genericity om de creatie en het gebruik van generieke klassen te beschrijven.

basis / onbeperkte genericiteitedit

Generieke klassen worden gedeclareerd met hun klassenaam en een lijst van een of meer formele generieke parameters., In de volgende code heeft Klasse LIST één formele generieke parameter G

de formele generieke parameters zijn placeholders voor willekeurige klassenamen die worden opgegeven wanneer een verklaring van de generieke klasse wordt gemaakt, zoals weergegeven in de twee generieke afleiding hieronder, waarbij ACCOUNT en DEPOSIT zijn andere klassenamen. ACCOUNT en DEPOSIT worden beschouwd als werkelijke generieke parameters omdat ze echte klassenamen leveren ter vervanging van G in daadwerkelijk gebruik.,

 list_of_accounts: LIST -- Account list list_of_deposits: LIST -- Deposit list

binnen het Eiffeltype wordt klasse LIST beschouwd als een klasse, maar niet als een type. Een generieke afleiding van LIST zoals LIST wordt echter als een type beschouwd.

beperkte genericiteitdit

voor de bovenstaande lijst-klasse kan een werkelijke generieke parameter die G vervangt, elke andere beschikbare klasse zijn., Om de verzameling klassen te beperken waaruit geldige werkelijke generieke parameters kunnen worden gekozen, kan een generieke beperking worden gespecificeerd. In de declaratie van klasse SORTED_LISThieronder, dicteert de generieke beperking dat elke geldige werkelijke generieke parameter een klasse zal zijn die van klasse COMPARABLE erft. De generieke beperking zorgt ervoor dat elementen van een SORTED_LIST in feite gesorteerd kunnen worden.,

class SORTED_LIST

Generics in JavaEdit

Main article: Generics in Java

Ondersteuning voor de generics, of “containers-of-type-T” werd toegevoegd aan de programmeertaal Java in 2004 als onderdeel van J2SE 5.0. In Java worden generics alleen gecontroleerd tijdens het compileren op type correctheid. De algemene type informatie wordt vervolgens verwijderd via een proces genaamd type erasure, om compatibiliteit met oude JVM implementaties te behouden, waardoor het niet beschikbaar is tijdens runtime., Bijvoorbeeld, een lijst<String> wordt geconverteerd naar de raw Type Lijst. De compiler voegt type casts om de elementen te converteren naar het type tekenreeks wanneer ze worden opgehaald uit de lijst, het verminderen van de prestaties in vergelijking met andere implementaties zoals C++ sjablonen.

Genericity in. net Edit

Generics werden toegevoegd als onderdeel van.NET Framework 2.0 In November 2005, gebaseerd op een onderzoek prototype van Microsoft Research gestart in 1999. Hoewel vergelijkbaar met generieke geneesmiddelen in Java,.,NET generics past geen type erasure toe, maar implementeert generics als een eersteklas mechanisme in de runtime met behulp van reification. Deze ontwerpkeuze biedt extra functionaliteit, zoals het toestaan van reflectie met behoud van generieke types, evenals het verlichten van een aantal van de beperkingen van Wissen (zoals het niet in staat zijn om generieke arrays te maken). Dit betekent ook dat er geen prestatie hit van runtime afgietsels en normaal dure boksen conversies., Wanneer primitieve en waarde types worden gebruikt als generieke argumenten, krijgen ze gespecialiseerde implementaties, waardoor efficiënte generieke collecties en methoden. Net als In C++ en Java zijn geneste generieke types zoals Dictionary<string, List<Int>> zijn geldige types, maar worden afgeraden voor handtekeningen van leden in ontwerpregels voor code-analyse.

.,NET staat zes variëteiten van generieke typebeperkingen toe met behulp van het where-trefwoord, waaronder het beperken van generieke typen om waardetypen te zijn, om klassen te zijn, om constructeurs te hebben en om interfaces te implementeren. Hieronder volgt een voorbeeld met een interface-beperking:

De MakeAtLeast() methode maakt het mogelijk om op arrays te werken, met elementen van generisch Type T. De typebeperking van de methode geeft aan dat de methode van toepassing is op elk type T dat de generieke IComparable<T> interface implementeert., Dit zorgt voor een compilatietijdfout, als de methode wordt aangeroepen als het type geen vergelijking ondersteunt. De interface biedt de generieke methode CompareTo (T).

de bovenstaande methode kan ook worden geschreven zonder generieke types, gewoon met behulp van het niet-generieke Array type. Echter, omdat arrays contravariant zijn, zou de casting niet type veilig zijn, en de compiler zou niet in staat zijn om bepaalde mogelijke fouten te vinden die anders zouden worden gevangen bij het gebruik van generieke types. Bovendien zou de methode in plaats daarvan toegang moeten krijgen tot de array-items als objecten, en zou casting nodig hebben om twee elementen te vergelijken., (Voor waarde types zoals types zoals int vereist dit een boxing conversie, hoewel dit kan worden gewerkt met behulp van de Comparer<T> klasse, zoals wordt gedaan in de standaard collectieklassen.)

een opmerkelijk gedrag van statische leden in een generieke. net klasse is statische member instantiation per runtime type (zie voorbeeld hieronder).

Genericity in DelphiEdit

Delphi ‘ s Object Pascal dialect verwierf generics in de Delphi 2007 release, aanvankelijk alleen met de (nu stopgezet) .,NET compiler voordat wordt toegevoegd aan de native code in de Delphi 2009 release. De semantiek en mogelijkheden van Delphi generics zijn grotendeels gemodelleerd naar die van generics in.NET 2.0, hoewel de implementatie per noodzaak heel anders is. Hier is een min of meer directe vertaling van het eerste C# voorbeeld hierboven:

net als bij C# kunnen zowel methoden als hele types één of meer type parameters hebben. In het voorbeeld, TArray is een generiek type (gedefinieerd door de taal) en MakeAtLeast een generieke methode., De beschikbare beperkingen zijn zeer vergelijkbaar met de beschikbare beperkingen in C#: elk waarde type, elke klasse, een specifieke klasse of interface, en een klasse met een parameterloze constructor. Meerdere beperkingen werken als een additieve Unie.

Genericity in Free PascalEdit

Free Pascal implementeerde generics voor Delphi, en met verschillende syntaxis en semantiek. Echter, sinds FPC Versie 2.6.0, is de Delphi-stijl syntaxis beschikbaar bij het gebruik van de {$mode Delphi} taal mode. Dus, Free Pascal programmeurs zijn in staat om generics te gebruiken in welke stijl ze willen.,

Delphi en Free Pascal voorbeeld:

Functional languagesEdit

Genericity in HaskellEdit

het type class mechanisme van Haskell ondersteunt generisch programmeren.Zes van de vooraf gedefinieerde type klassen in Haskell (inclusief Eq, de types die kunnen worden vergeleken voor gelijkheid, en Show, de types waarvan de waarden kunnen worden weergegeven als strings) hebben de speciale eigenschap van het ondersteunen van afgeleide instanties., Dit betekent dat een programmeur die een nieuw type definieert kan stellen dat dit type een instantie van een van deze speciale type klassen moet zijn, zonder implementaties van de klasse methoden te leveren zoals gewoonlijk nodig is bij het declareren van klasse instanties. Alle noodzakelijke methoden zullen worden “afgeleid” – dat wil zeggen automatisch geconstrueerd-op basis van de structuur van het type.,Bijvoorbeeld, de volgende declaratie van een type binaire bomen stelt dat het een instantie van de klassen Eq en Show moet zijn:

data BinTree a = Leaf a | Node (BinTree a) a (BinTree a) deriving (Eq, Show)

Dit resulteert in een gelijkheidsfunctie (==) en een tekenreeksrepresentatiefunctie (show) die automatisch wordt gedefinieerd voor elk type van het formulier BinTree T op voorwaarde dat T zelf deze bewerkingen ondersteunt.,

de ondersteuning voor afgeleide instanties van EQ en Show maakt hun methoden == en tonen generiek op een kwalitatief andere manier dan para-metrisch polymorfe functies: deze “functies” (nauwkeuriger, type-geïndexeerde families van functies) kunnen worden toegepast op waarden van verschillende typen, en hoewel ze zich anders gedragen voor elk argumenttype, is er weinig werk nodig om ondersteuning toe te voegen voor een nieuw type. Ralf Hinze (2004) heeft aangetoond dat een vergelijkbaar effect kan worden bereikt voor door de gebruiker gedefinieerde type klassen door bepaalde programmeertechnieken., Andere onderzoekers hebben benaderingen van deze en andere vormen van genericiteit voorgesteld in de context van Haskell en uitbreidingen naar Haskell (hieronder besproken).

PolyPEdit

PolyP was de eerste generieke extensie voor Haskell. In poliep worden generieke functies polytypisch genoemd. De taal introduceert een speciale constructie waarin dergelijke polytypische functies kunnen worden gedefinieerd via structurele inductie over de structuur van de patroonfunctor van een regelmatig datatype. Regelmatige datatypes in poliep zijn een subset van Haskell datatypes., Een regulier datatype t moet van soort zijn*→*, en als a het formele type argument is in de definitie, dan moeten alle recursieve aanroepen naar t de vorm t a hebben. deze beperkingen sluiten hogere-kinded datatypes uit evenals geneste datatypes, waar de recursieve aanroepen van een andere vorm zijn.De flatten-functie in poliep wordt hier als voorbeeld gegeven:

Generic HaskellEdit

Generic Haskell is een andere uitbreiding van Haskell, ontwikkeld aan de Universiteit Utrecht in Nederland., De uitbreidingen die het biedt zijn:

  • Type-geïndexeerde waarden zijn gedefinieerd als een waarde geïndexeerd over de verschillende Haskell type constructors (eenheid, primitieve types, sommen, producten, en door de gebruiker gedefinieerde type constructors). Daarnaast kunnen we ook het gedrag van een type-geïndexeerde waarden voor een specifieke constructor specificeren met behulp van constructor cases, en een generieke definitie hergebruiken in een andere met behulp van standaard cases.

de resulterende type-geïndexeerde waarde kan naar elk type worden gespecialiseerd.

  • soort-geïndexeerde types zijn types geïndexeerd over soorten, gedefinieerd door een case te geven voor zowel * als k → k’., Instanties worden verkregen door het type-geïndexeerd op een soort toe te passen.
  • Generieke definities kunnen worden gebruikt door ze toe te passen op een type of Soort. Dit wordt generieke toepassing genoemd. Het resultaat is een type of waarde, afhankelijk van welk soort generieke definitie wordt toegepast.
  • Generic abstraction maakt het mogelijk generieke definities te definiëren door een typeparameter (van een bepaalde soort) te abstraheren.
  • type-geïndexeerde types zijn types die worden geïndexeerd over de type constructors. Deze kunnen worden gebruikt om types te geven aan meer betrokken generieke waarden., De resulterende type-geïndexeerde types kunnen worden gespecialiseerd in elk type.

als voorbeeld biedt de equality-functie in Generic Haskell:

CleanEdit

Clean generic programming based poliep en de generic Haskell zoals ondersteund door de GHC>=6.0. Het parametrizes op soort als die, maar biedt overbelasting.

andere languagesEdit

De ML-familie van programmeertalen ondersteunt generisch programmeren door middel van parametrisch polymorfisme en generieke modules genaamd functors.,Zowel Standard ML als OCaml bieden functors, die vergelijkbaar zijn met class templates en Ada ‘ s generieke pakketten. Schema syntactische abstracties hebben ook een verband met genericiteit – deze zijn in feite een superset van templating à la c++.

een Verilog-module kan een of meer parameters aannemen, waaraan hun werkelijke waarden worden toegekend bij de instantiatie van de module. Een voorbeeld is een generieke register array waar de array breedte wordt gegeven via een parameter., Zo kan de array, gecombineerd met een generieke draadvector, een generieke buffer of geheugenmodule maken met een willekeurige bitbreedte uit een enkele module implementatie.

VHDL, afgeleid van Ada, heeft ook generieke mogelijkheden.