Partager via

autoriser les liaisons

Une liaison associe un identificateur à une valeur ou une fonction. Vous utilisez le let mot clé 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

Remarques

Le let mot clé 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 à l’aide d’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 nom, un modèle qui contient des noms peut être spécifié, par exemple un tuple, comme illustré dans le code suivant.

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

L’expression de corps est l’expression dans laquelle les noms sont utilisés. L’expression du corps apparaît sur sa propre ligne, mise en retrait pour s’aligner exactement avec le premier caractère du let mot clé :

let result =

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

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

Une let liaison peut apparaître au niveau du module, dans la définition d’un type de classe ou dans des étendues locales, comme dans une définition de fonction. Une let liaison au niveau supérieur dans un module ou dans 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 requise. Les noms liés sont utilisables après le point de définition, mais pas à aucun moment avant l’affichage de la let liaison, 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 incluent 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, tels qu’un modèle tuple :

let function2 (a, b) = a + b

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

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

Pour plus d’informations, consultez Functions.

Type Annotations

Vous pouvez spécifier des types pour les paramètres en incluant un signe deux-points (:) suivi d’un nom de type, tous placés 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 complet pour function1, avec des entiers comme types de paramètres, seraient les suivantes.

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

Lorsqu’il n’existe aucun paramètre de type explicite, l’inférence de type est utilisée pour déterminer les types de paramètres de fonctions. Cela peut inclure la généralisation automatique du type d’un paramètre à générique.

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

autoriser les liaisons dans les classes

Une let liaison peut apparaître dans un type de classe, mais pas dans une structure ou un type 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 du type dans la définition de classe. Une let liaison dans un type de classe définit des champs privés et des membres pour ce type de classe et, avec do des liaisons dans le type, forme le code du constructeur principal pour le type. Les exemples de code suivants montrent une classe MyClass avec des champs field1 privés 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 et field1field2 sont limitées au type dans lequel ils sont déclarés. Pour plus d’informations, consultez let Liaisons dans les classes et les classes.

Paramètres de type dans let Bindings

Une let liaison 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, telle qu’au sein d’une définition de fonction, ne peut pas avoir de paramètres de type. Pour plus d’informations, consultez Génériques.

Attributs sur let Bindings

Les attributs peuvent être appliqués à des liaisons de niveau let 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 conteneur (par exemple, une fonction, un module, un fichier ou une classe) une fois la liaison affichée. Par conséquent, il peut être dit qu’une liaison let introduit un nom dans une étendue. Dans un module, une valeur ou une fonction à liaison let est accessible aux clients d’un module tant que le module est accessible, car les liaisons let d’un module sont compilées en fonctions publiques du module. En revanche, laissez les liaisons dans une classe privées à la classe.

Normalement, les fonctions dans les modules doivent être qualifié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écifient Module1.function1 de faire référence à la fonction.

Les utilisateurs d’un module peuvent utiliser une déclaration d’importation pour rendre les fonctions au sein de ce module disponibles pour une utilisation sans être qualifiés par le nom du module. Dans l’exemple mentionné simplement, les utilisateurs du module peuvent, dans ce cas, ouvrir le module à l’aide de la déclaration open Module1 d’importation, puis faire référence 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 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

  • Last updated on