Liaisons let

  • Article

Une liaison associe un identificateur à une valeur ou une fonction. Vous utilisez le mot clé let pour lier un nom à une valeur ou une fonction.

Syntaxe

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

Notes

Le mot clé let est utilisé dans les expressions de liaison pour définir des valeurs ou des valeurs de fonction pour un ou plusieurs noms. La forme la plus simple de l’expression let lie un nom à une valeur simple, de la façon suivante.

let i = 1

Si vous séparez l’expression et l’identificateur par une nouvelle ligne, vous devez mettre en retrait chaque ligne de l’expression, comme dans le code suivant.

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

Au lieu d’un simple nom, un modèle contenant des noms peut être spécifié, par exemple, un tuple, comme indiqué dans le code suivant.

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

body-expression est l’expression dans laquelle les noms sont utilisés. L’expression de corps apparaît sur sa propre ligne, mise en retrait au même niveau exactement que le premier caractère du mot clé let :

let result =

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

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

Une liaison let peut apparaître au niveau du module, dans la définition d’un type de classe ou dans des étendues locales, par exemple, une définition de fonction. Une liaison let au niveau supérieur d’un module ou d’un type de classe n’a pas besoin d’avoir une expression de corps, mais à d’autres niveaux d’étendue, l’expression de corps est nécessaire. Les noms liés sont utilisables après le point de définition, mais pas pour n’importe quel point avant la liaison let, comme illustré dans le code suivant.

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

Liaisons de fonction

Les liaisons de fonction suivent les règles des liaisons de valeur, sauf que les liaisons de fonction comprennent le nom de la fonction et les paramètres, comme indiqué dans le code suivant.

let function1 a = a + 1

En général, les paramètres sont des modèles, comme un modèle de tuple :

let function2 (a, b) = a + b

Une expression de liaison let a la valeur de la dernière expression. Par conséquent, dans l’exemple de code suivant, la valeur de result est calculée à partir de 100 * function3 (1, 2), qui a la valeur 300.

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

Pour plus d’informations, consultez Fonctions.

Annotations de type

Vous pouvez spécifier des types pour les paramètres en incluant un signe deux-points (:) suivi d’un nom de type, le tout entre parenthèses. Vous pouvez également spécifier le type de la valeur renvoyée en ajoutant les deux-points et le type après le dernier paramètre. Les annotations de type complet pour function1, avec des entiers comme types de paramètre, sont les suivantes.

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

Quand il n’y a pas de paramètre de type explicite, l’inférence de type est utilisée pour déterminer le type des paramètre des fonctions. Cela peut inclure la généralisation automatique du type d’un paramètre pour qu’il soit générique.

Pour plus d’informations, consultez Généralisation automatique et Inférence de type.

Liaisons let dans des classes

Une liaison let peut apparaître dans un type de classe, mais pas dans un type de structure ou d’enregistrement. Pour utiliser une liaison let dans un type de classe, la classe doit avoir un constructeur principal. Les paramètres du constructeur doivent apparaître après le nom de type dans la définition de classe. Une liaison let dans un type de classe définit des membres et des champs privés pour ce type de classe et, avec des liaisons do dans le type, forme le code du constructeur principal pour le type. Les exemples de code suivants montrent une classe MyClass avec des champs privés field1 et 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

Les étendues de field1 et field2 sont limitées au type dans lequel elles sont déclarées. Pour plus d’informations, consultez Liaisons let dans les classes et Classes.

Paramètres de type dans les liaisons let

Une liaison let au niveau du module, dans un type ou dans une expression de calcul, peut avoir des paramètres de type explicites. Une liaison let dans une expression, comme une définition de fonction, ne peut pas avoir de paramètres de type. Pour plus d’informations, consultez Génériques.

Attributs sur les liaisons let

Des attributs peuvent être appliqués aux liaisons let de niveau supérieur dans un module, comme indiqué dans le code suivant.

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

Étendue et accessibilité des liaisons let

L’étendue d’une entité déclarée avec une liaison let est limitée à la partie de l’étendue contenante (comme une fonction, un module, un fichier ou une classe) après la liaison. Par conséquent, on peut dire qu’une liaison let introduit un nom dans une étendue. Dans un module, une valeur ou une fonction avec une liaison let est accessible aux clients d’un module si le module est accessible, car les liaisons let d’un module sont compilées dans les fonctions publiques du module. En revanche, les liaisons let d’une classe sont privées et réservées la classe.

Normalement, les fonctions dans les modules doivent être qualifiées par le nom du module quand elles sont utilisées par le code client. Par exemple, si un module Module1 a une fonction function1, les utilisateurs spécifient Module1.function1 pour référencer la fonction.

Les utilisateurs d’un module peuvent utiliser une déclaration d’importation pour que les fonctions de ce module soient disponibles sans être qualifiés par le nom du module. Dans l’exemple qui vient d’être mentionné, les utilisateurs du module peuvent dans ce cas ouvrir le module en utilisant la déclaration d’importation open Module1 et référencer ensuite directement function1.

module Module1 =
    let function1 x = x + 1.0

module Module2 =
    let function2 x =
        Module1.function1 x

open Module1

let function3 x =
    function1 x

Certains modules ont l’attribut RequireQualifiedAccess, ce qui signifie que les fonctions qu’ils exposent doivent être qualifiées avec le nom du module. Par exemple, le module F# List a cet attribut.

Pour plus d’informations sur les modules et le contrôle d’accès, consultez Modules et Contrôle d’accès.

Voir aussi