Liaisons let (F#)
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.
// Binding a value:
let identifier-or-pattern [: type] =
expression
body-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =
expression
body-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, comme suit.
let i = 1
Si vous séparez l'expression de l'identificateur en utilisant 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 qui contient 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 et est mise en retrait pour s'aligner exactement avec 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 portées locales, par exemple dans 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 ; cependant, à d'autres niveaux de portée, l'expression de corps est obligatoire. Les noms liés sont utilisables après le point de définition, mais pas avant l'apparition de la liaison let, comme cela est 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 pour les liaisons de valeur, à la différence que les liaisons de fonction incluent le nom et les paramètres de fonction, comme indiqué dans le code suivant.
let function1 a =
a + 1
En général, les paramètres sont des modèles, par exemple un modèle de tuple :
let function2 (a, b) = a + b
Une expression de liaison let prend 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 prend la valeur 300.
let result =
let function3 (a, b) = a + b
100 * function3 (1, 2)
Pour plus d’informations, consultez Fonctions (F#).
Annotations de type
Vous pouvez spécifier des types pour des paramètres en incluant le signe deux-points (:) suivi d'un nom de type, le tout entre parenthèses. Vous pouvez également spécifier le type de la valeur de retour en ajoutant le signe deux-points et le type après le dernier paramètre. Les annotations de type complètes pour function1, avec des entiers comme types de paramètre, apparaîtraient comme suit.
let function1 (a: int) : int = a + 1
Lorsqu'il n'y a pas de paramètres de type explicite, l'inférence de type est utilisée pour déterminer les types de paramètres de fonctions. Il peut s'agir de la généralisation automatique du type d'un paramètre en générique.
Pour plus d'informations, consultez Généralisation automatique (F#) et Inférence de type (F#).
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 de 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. Elle forme, conjointement avec les liaisons do dans le type, le code pour le constructeur principal du type. Les exemples de code suivants montrent une classe MyClass avec les 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 portées des champs field1 et de field2 sont limitées au type dans lequel ils sont déclarés. Pour plus d'informations, consultez Liaisons let dans les classes (F#) et Classes (F#).
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 explicite. Une liaison let dans une expression, par exemple dans une définition de fonction, ne peut pas avoir de paramètres de type. Pour plus d’informations, consultez Génériques (F#).
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
Portée et accessibilité des liaisons let
La portée d'une entité déclarée avec la liaison Let est limitée à la partie de la portée contenante (telle qu'une fonction, un module, un fichier ou une classe) après l´apparition de la liaison. Par conséquent, il peut indiquer que la liaison Let introduit un nom dans une portée. Dans un module, une valeur ou une fonction liaison let est accessible par les clients d'un module tant que le module est accessible, puisque les liaisons Let dans un package sont compilés dans des fonctions publiques du module. En revanche, les liaisons Let dans une classe sont privés à la classe.
En principe, les fonctions dans les modules doivent être désignées par le nom du module lorsqu'elles sont utilisées par le code client. Par exemple, si un module Module1 a une fonction function1, les utilisateurs spécifieraient Module1.function1 pour faire référence à la fonction.
Les utilisateurs d'un module peuvent utiliser une déclaration d'importation pour que les fonctions dans ce module soient disponible sans être qualifié par le nom du module. Dans l'exemple indiqué, les utilisateurs du module peuvent dans ce cas ouvrir le module en utilisant la déclaration d'importation Module1 et font référence ensuite à function1 directement.
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 désignées avec le nom du module. Par exemple, le module liste F# possède cet attribut.
Pour plus d'informations sur les modules et le contrôle d'accès, consultez Modules (F#) et Contrôle d'accès (F#).