Type-inferentie

In de informatica duidt type-inferentie (Engels: Type inference), of impliciete typering, op de mogelijkheid van sommige programmeertalen om automatisch het datatype van een expressie te bepalen. Een programmeertaal die type-inferentie ondersteunt is in staat om zelf de typen van bepaalde expressies in een programma te bepalen, waardoor de programmeur deze niet hoeft te specificeren. De meeste functionele programmeertalen ondersteunen type-inferentie, maar ook sommige talen die niet functioneel zijn (maar wel sterk en statisch getypeerd zijn) bieden type-inferentie.

Het voordeel van type-inferentie is dat de programmeur niet verplicht is alle typen expliciet te declareren, terwijl tegelijkertijd een sterke mate van "type safety" (het voorkomen en detecteren van typefouten) mogelijk blijft.

Het deduceren van de typen van alle expressies in een programma gebeurt tijdens het compileren (compile time). De compiler bepaalt de types van samengestelde expressies aan de hand van de samenstellende expressies. De type signatures van functies die door de gebruiker gedefinieerd worden wordt bepaald aan de hand van het gebruik van de parameters in de functiedefinities. Omdat op deze manier het type van alle gebruikte variabelen en gedefinieerde functies door de compiler bepaald kan worden, kunnen type-declaraties vaak helemaal achterwege gelaten worden.

Het verschil met dynamische typering is dat type-inferentie plaatsvindt tijdens het compileren, voordat het programma uitgevoerd wordt, terwijl bij dynamische typering het bepalen van de typen pas plaatsvindt tijdens de uitvoer van het programma.

Enkele voorbeelden van programmeertalen die in meer of mindere mate type-inferentie ondersteunen zijn Haskell, OCaml, F#, Vala, Scala en recente versies van C++, C# en Java.

Voorbeeld

Neem het volgende fragment in pseudocode:

  function f(a) {
    b = a % 2;
    return b;
  }

  x = f(4);
  print x;

Omdat de parameter a gebruikt wordt als operand van de modulusoperatie is het type van a int. Het resultaat van een modulusoperatie is ook een integer, dus het type van b is ook int. En daarmee is dus ook de returnexpressie van f() van het type int. De type-signatuur van f is dus int -> int. Omdat de compiler nu weet dat f() een int oplevert, weet hij dat het type van de expressie f(4) ook int is. En daarmee is het type van variabele x ook int.

De compiler kent nu de typen van alle lokale variabelen (a en b), van alle globale variabelen (x) en alle gedeclareerde functies (f()). Er zijn geen typefouten en het programma kan gecompileerd worden.

In een taal zonder type-inferentie waarin alle typen gedeclareerd moeten worden zou de bovenstaande pseudocode er ongeveer als volgt uit kunnen zien:

  function f(int a): int {
    int b = a % 2;
    return b;
  }

  int x = f(4);
  print x;

Zie ook

• Functioneel programmeren
• Haskell
• Scala
• Typesysteem

Bronnen, noten en/of referenties