Delen via

Type deductie

  • Artikel

In dit onderwerp wordt beschreven hoe de F#-compiler de typen waarden, variabelen, parameters en retourwaarden afstelt.

Type deductie in Algemeen

Het idee van typedeductie is dat u niet de typen F#-constructies hoeft op te geven, behalve wanneer de compiler het type niet kan afleiden. Het weglaten van expliciete typegegevens betekent niet dat F# een dynamisch getypte taal is of dat waarden in F# zwak zijn getypt. F# is een statisch getypte taal, wat betekent dat de compiler een exact type voor elke constructie afleidt tijdens de compilatie. Als er onvoldoende informatie is voor de compiler om de typen van elke constructie te afleiden, moet u aanvullende typegegevens opgeven, meestal door expliciete typeaantekeningen ergens in de code toe te voegen.

Deductie van parameter- en retourtypen

In een parameterlijst hoeft u niet het type van elke parameter op te geven. En toch is F# een statisch getypte taal, en daarom heeft elke waarde en expressie een bepaald type tijdens het compileren. Voor de typen die u niet expliciet opgeeft, wordt het type afgeleid door de compiler op basis van de context. Als het type niet anders is opgegeven, wordt het afgeleid om algemeen te zijn. Als de code een waarde inconsistent gebruikt, op een zodanige manier dat er geen enkel afgeleid type is dat voldoet aan alle toepassingen van een waarde, rapporteert de compiler een fout.

Het retourtype van een functie wordt bepaald door het type van de laatste expressie in de functie.

In de volgende code worden bijvoorbeeld de parametertypen a en b het retourtype allemaal afgeleid int omdat de letterlijke waarde 100 van het type intis.

let f a b = a + b + 100

U kunt invloed hebben op typedeductie door de letterlijke gegevens te wijzigen. Als u het 100uint32 achtervoegsel maakt door het achtervoegsel utoe te voegen, worden de typen aen bde retourwaarde afgeleid.uint32

U kunt ook invloed hebben op typedeductie door andere constructies te gebruiken die beperkingen impliceren voor het type, zoals functies en methoden die alleen met een bepaald type werken.

U kunt ook expliciete typeaantekeningen toepassen op functie- of methodeparameters of op variabelen in expressies, zoals wordt weergegeven in de volgende voorbeelden. Fouten resulteren als er conflicten optreden tussen verschillende beperkingen.

// Type annotations on a parameter.
let addu1 (x : uint32) y =
    x + y

// Type annotations on an expression.
let addu2 x y =
    (x : uint32) + y

U kunt ook expliciet de retourwaarde van een functie opgeven door een typeaantekening op te geven na alle parameters.

let addu1 x y : uint32 =
   x + y

Een veelvoorkomend geval waarin een typeaantekening nuttig is voor een parameter is wanneer de parameter een objecttype is en u een lid wilt gebruiken.

let replace(str: string) =
    str.Replace("A", "a")

Automatische generalisatie

Als de functiecode niet afhankelijk is van het type parameter, beschouwt de compiler de parameter als algemeen. Dit wordt automatische generalisatie genoemd en het kan een krachtige hulp zijn bij het schrijven van algemene code zonder de complexiteit te vergroten.

De volgende functie combineert bijvoorbeeld twee parameters van elk type in een tuple.

let makeTuple a b = (a, b)

Het type wordt afgeleid

'a -> 'b -> 'a * 'b

Aanvullende informatie

Typedeductie wordt uitgebreid beschreven in de F#-taalspecificatie.

Zie ook