let-Bindungen

Artikel
06/26/2023

Eine Bindung ordnet einen Bezeichner einem Wert oder einer Funktion zu. Sie verwenden das let-Schlüsselwort, um einen Namen an einen Wert oder eine Funktion zu binden.

Syntax

// Binding a value:
let identifier-or-pattern [: type] =expressionbody-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =expressionbody-expression

Bemerkungen

Das let-Schlüsselwort wird in Bindungsausdrücken verwendet, um Werte oder Funktionswerte für einen oder mehrere Namen zu definieren. Die einfachste Form des let-Ausdrucks bindet einen Namen wie folgt an einen einfachen Wert.

let i = 1

Wenn Sie den Ausdruck vom Bezeichner mithilfe einer neuen Zeile trennen, müssen Sie wie im folgenden Code jede Zeile des Ausdrucks einrücken.

let someVeryLongIdentifier =
    // Note indentation below.
    3 * 4 + 5 * 6

Anstelle eines Namens kann ein Muster angegeben werden, das Namen enthält, z. B. ein Tupel, wie im folgenden Code gezeigt.

let i, j, k = (1, 2, 3)

Der Textausdruck ist der Ausdruck, in dem die Namen verwendet werden. Der Textausdrucks steht in einer eigenen Zeile, die so eingerückt ist, dass sie genau mit dem ersten Zeichen des let-Schlüsselworts übereinstimmt:

let result =

    let i, j, k = (1, 2, 3)

    // Body expression:
    i + 2 * j + 3 * k

Eine let-Bindung kann auf Modulebene, in der Definition eines Klassentyps oder in lokalen Bereichen, z. B. in einer Funktionsdefinition, angezeigt werden. Eine let-Bindung auf der obersten Ebene in einem Modul oder in einem Klassentyp benötigt keinen Textausdruck, aber auf anderen Bereichsebenen ist der Textausdruck erforderlich. Die gebundenen Namen können nach dem Zeitpunkt der Definition verwendet werden, aber nicht zu einem Zeitpunkt, bevor die let-Bindung angezeigt wird, wie im folgenden Code veranschaulicht.

// Error:
printfn "%d" x
let x = 100
// OK:
printfn "%d" x

Funktionsbindungen

Funktionsbindungen folgen den Regeln für Wertbindungen, mit der Ausnahme, dass Funktionsbindungen den Funktionsnamen und die Parameter enthalten, wie im folgenden Code gezeigt.

let function1 a = a + 1

Im Allgemeinen handelt es sich bei Parametern um Muster, z. B. ein Tupelmuster:

let function2 (a, b) = a + b

Ein let-Bindungsausdruck wird mit dem Wert des letzten Ausdrucks ausgewertet. Daher wird im folgenden Codebeispiel der Wert von result aus 100 * function3 (1, 2) berechnet, was 300 ergibt.

let result =
    let function3 (a, b) = a + b
    100 * function3 (1, 2)

Weitere Informationen finden Sie unter Funktionen.

Typanmerkungen

Sie können Typen für Parameter angeben, indem Sie einen Doppelpunkt (:), gefolgt von einem Typnamen, in Klammern setzen. Sie können auch den Typ des Rückgabewerts angeben, indem Sie den Doppelpunkt und den Typ nach dem letzten Parameter anfügen. Die vollständigen Typanmerkungen für function1, mit ganzen Zahlen als Parametertypen, würden wie folgt aussehen.

let function1 (a: int) : int = a + 1

Wenn keine expliziten Typparameter vorhanden sind, wird der Typrückschluss verwendet, um die Typen von Parametern von Funktionen zu bestimmen. Dies kann die automatische Generalisierung des Typs eines Parameters umfassen, der generisch ist.

Weitere Informationen finden Sie unter Automatische Verallgemeinerung und Typrückschluss.

let-Bindungen in Klassen

Eine let-Bindung kann in einem Klassentyp, aber nicht in einer Struktur oder einem Datensatztyp angezeigt werden. Um eine let-Bindung in einem Klassentyp verwenden zu können, muss die Klasse über einen primären Konstruktor verfügen. Konstruktorparameter müssen nach dem Typnamen in der Klassendefinition angezeigt werden. Eine let-Bindung in einem Klassentyp definiert private Felder und Member für diesen Klassentyp und bildet zusammen mit do-Bindungen im Typ den Code für den primären Konstruktor für den Typ. Die folgenden Codebeispiele zeigen eine Klasse MyClass mit privaten Feldern field1 und field2.

type MyClass(a) =
    let field1 = a
    let field2 = "text"
    do printfn "%d %s" field1 field2
    member this.F input =
        printfn "Field1 %d Field2 %s Input %A" field1 field2 input

Die Bereiche von field1 und field2 sind auf den Typ beschränkt, in dem sie deklariert werden. Weitere Informationen finden Sie unter let-Bindungen in Klassen und Klassen.

Typparameter in let-Bindungen

Eine let-Bindung auf Modulebene, in einem Typ oder in einem Berechnungsausdruck kann explizite Typparameter aufweisen. Eine let-Bindung in einem Ausdruck, z. B. innerhalb einer Funktionsdefinition, darf keine Typparameter aufweisen. Weitere Informationen finden Sie unter Generics.

Attribute für let-Bindungen

Attribute können auf let-Bindungen der obersten Ebene in einem Modul angewendet werden, wie im folgenden Code gezeigt.

[<Obsolete>]
let function1 x y = x + y

Bereich und Barrierefreiheit von Let-Bindungen

Der Bereich einer Entität, die mit einer let-Bindung deklariert wird, ist nach dem Erscheinen der Bindung auf den Teil des enthaltenden Bereichs (z. B. eine Funktion, ein Modul, eine Datei oder eine Klasse) beschränkt. Daher kann gesagt werden, dass eine let-Bindung einen Namen in einen Bereich einführt. In einem Modul kann auf einen let-gebundenen Wert oder eine let-gebundene Funktion für Clients eines Moduls zugegriffen werden, solange auf das Modul zugegriffen werden kann, da die let-Bindungen in einem Modul in öffentliche Funktionen des Moduls kompiliert werden. Im Gegensatz dazu sind let-Bindungen in einer Klasse privat für die Klasse.

Normalerweise müssen Funktionen in Modulen durch den Namen des Moduls qualifiziert werden, wenn sie vom Clientcode verwendet werden. Wenn ein Modul Module1 z. B. über eine Funktion function1 verfügt, geben Benutzer*innen Module1.function1 an, um auf die Funktion zu verweisen.

Benutzer*innen eines Moduls können eine Importdeklaration verwenden, um die Funktionen in diesem Modul zur Verwendung zur Verfügung zu stellen, ohne durch den Modulnamen qualifiziert zu werden. Im soeben erwähnten Beispiel können Benutzer*innen des Moduls in diesem Fall das Modul mithilfe der Importdeklaration open Module1 öffnen und anschließend direkt auf function1 verweisen.

module Module1 =
    let function1 x = x + 1.0

module Module2 =
    let function2 x =
        Module1.function1 x

open Module1

let function3 x =
    function1 x

Einige Module weisen das Attribut RequireQualifiedAccess auf. Dies bedeutet, dass die Funktionen, die sie verfügbar machen, mit dem Namen des Moduls qualifiziert werden müssen. Das F#-Listenmodul hat zum Beispiel dieses Attribut.

Weitere Informationen zu Modulen und zur Zugriffssteuerung finden Sie unter Module und Zugriffssteuerung.