Typableitung

In diesem Thema wird beschrieben, wie der F#-Compiler die Typen von Werten, Variablen, Parametern und Rückgabewerten ableiten kann.

Typinferenz im Allgemeinen

Die Idee der Typeinschlussfolge besteht darin, dass Sie nicht die Typen von F#-Konstrukten angeben müssen, außer wenn der Compiler den Typ nicht abschließend ableiten kann. Das Weglassen expliziter Typinformationen bedeutet nicht, dass F# eine dynamisch eingegebene Sprache ist oder dass Werte in F# schwach typiert sind. F# ist eine statisch typierte Sprache, was bedeutet, dass der Compiler einen genauen Typ für jedes Konstrukt während der Kompilierung ableite. Wenn nicht genügend Informationen vorhanden sind, damit der Compiler die Typen der einzelnen Konstrukte ableiten kann, müssen Sie zusätzliche Typinformationen angeben, in der Regel durch Hinzufügen expliziter Typanmerkungen an einer beliebigen Stelle im Code.

Ableitung von Parameter- und Rückgabetypen

In einer Parameterliste müssen Sie nicht den Typ der einzelnen Parameter angeben. Und dennoch ist F# eine statisch typierte Sprache, und daher hat jeder Wert und Ausdruck zur Kompilierungszeit einen bestimmten Typ. Für diese Typen, die Sie nicht explizit angeben, leitet der Compiler den Typ basierend auf dem Kontext ab. Wenn der Typ nicht andernfalls angegeben ist, wird er als generisch abgeleitet. Wenn der Code einen Wert inkonsistent verwendet, so dass kein einzelner abgeleiteter Typ vorhanden ist, der alle Verwendungen eines Werts erfüllt, meldet der Compiler einen Fehler.

Der Rückgabetyp einer Funktion wird durch den Typ des letzten Ausdrucks in der Funktion bestimmt.

Im folgenden Code werden beispielsweise die Parametertypen a und b der Rückgabetyp abgeleitet int , da das Literal 100 vom Typ intist.

let f a b = a + b + 100

Sie können die Typeinleitung beeinflussen, indem Sie die Literale ändern. Wenn Sie die a uint32 erstellen100, indem Sie das Suffix uanfügen, werden die Typen von a, bund der Rückgabewert abgeleitet.uint32

Sie können auch den Typeinschluss beeinflussen, indem Sie andere Konstrukte verwenden, die Einschränkungen für den Typ bedeuten, z. B. Funktionen und Methoden, die nur mit einem bestimmten Typ funktionieren.

Außerdem können Sie explizite Typanmerkungen auf Funktions- oder Methodenparameter oder Variablen in Ausdrücken anwenden, wie in den folgenden Beispielen gezeigt. Fehler führen dazu, wenn Konflikte zwischen verschiedenen Einschränkungen auftreten.

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

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

Sie können auch explizit den Rückgabewert einer Funktion angeben, indem Sie nach allen Parametern eine Typanmerkung angeben.

let addu1 x y : uint32 =
   x + y

Ein gängiger Fall, bei dem eine Typanmerkung für einen Parameter nützlich ist, ist, wenn der Parameter ein Objekttyp ist und Sie ein Element verwenden möchten.

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

Automatische Generalisierung

Wenn der Funktionscode nicht vom Typ eines Parameters abhängig ist, berücksichtigt der Compiler den Parameter als generisch. Dies wird als automatische Generalisierung bezeichnet, und es kann eine leistungsstarke Hilfe beim Schreiben von generischem Code sein, ohne die Komplexität zu erhöhen.

Die folgende Funktion kombiniert beispielsweise zwei Parameter eines beliebigen Typs in einem Tupel.

let makeTuple a b = (a, b)

Der Typ wird abgeleitet,

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

Zusatzinformation

Die Typreferenz wird in der F#-Sprachspezifikation ausführlicher beschrieben.

Siehe auch

• Automatische Generalisierung