Modules (F#)
Dans le contexte du langage F#, un module est un regroupement de code F#, notamment des valeurs, des types et des valeurs de fonction, dans un programme F#. Le regroupement de code en modules vous permet de centraliser le code connexe et d'éviter les conflits de nom dans votre programme.
// Top-level module declaration.
module [accessibility-modifier] [qualified-namespace.]module-name
declarations
// Local module declaration.
module [accessibility-modifier] module-name =
declarations
Notes
Un module F# est un regroupement de constructions de code F#, notamment des types, des valeurs, des valeurs de fonction et du code dans des liaisons do. Il est implémenté en tant que classe du Common Language Runtime (CLR) avec uniquement des membres statiques. Il existe deux types de déclarations de module, selon que le fichier entier est inclus ou non dans le module : une déclaration de module de niveau supérieur et une déclaration de module locale. Une déclaration de module de niveau supérieur inclut le fichier entier dans le module. Une déclaration de module de niveau supérieur peut apparaître uniquement comme la première déclaration dans un fichier.
Dans la syntaxe pour la déclaration de module de niveau supérieur, le qualified-namespace facultatif est la séquence de noms d'espace de noms imbriqués qui contient le module. L'espace de noms qualifié ne doit pas nécessairement être déclaré précédemment.
Il est inutile de mettre en retrait les déclarations dans un module de niveau supérieur. Vous devez mettre en retrait toutes les déclarations dans les modules locaux. Dans une déclaration de module locale, seules les déclarations mises en retrait sous cette déclaration de module font partie du module.
Si un fichier de code ne commence pas par une déclaration de module de niveau supérieur ou une déclaration d'espace de noms, le contenu entier du fichier, y compris tous les modules locaux, devient partie intégrante d'un module de niveau supérieur créé implicitement et ayant le même nom que le fichier, sans l'extension, et avec la première lettre convertie en majuscule. Prenons par exemple le fichier suivant.
// In the file program.fs.
let x = 40
Ce fichier est compilé comme s'il avait été écrit de cette manière :
module Program
let x = 40
Si un fichier comprend plusieurs modules, vous devez utiliser une déclaration de module locale pour chaque module. Si un espace de noms englobant est déclaré, ces modules font partie de l'espace de noms englobant. Si un espace de noms englobant n'est pas déclaré, les modules deviennent partie intégrante du module de niveau supérieur créé implicitement. L'exemple de code suivant montre un fichier de code qui contient plusieurs modules. Le compilateur crée implicitement un module de niveau supérieur nommé Multiplemodules, et MyModule1 et MyModule2 sont imbriqués dans ce module de niveau supérieur.
// In the file multiplemodules.fs.
// MyModule1
module MyModule1 =
// Indent all program elements within modules that are declared with an equal sign.
let module1Value = 100
let module1Function x =
x + 10
// MyModule2
module MyModule2 =
let module2Value = 121
// Use a qualified name to access the function.
// from MyModule1.
let module2Function x =
x * (MyModule1.module1Function module2Value)
Si vous avez plusieurs fichiers dans un projet ou dans une compilation unique, ou si vous générez une bibliothèque, vous devez inclure une déclaration d'espace de noms ou une déclaration de module en haut du fichier. Le compilateur F# ne détermine un nom de module implicitement que lorsqu'il n'y a qu'un fichier dans un projet ou ligne de commande de compilation, et que vous créez une application.
accessibility-modifier peut avoir l'une des valeurs suivantes : public, private ou internal. Pour plus d'informations, consultez Contrôle d'accès (F#). La valeur par défaut est public.
Référencement du code dans des modules
Lorsque vous référencez des fonctions, des types et des valeurs à partir d'un autre module, vous devez utiliser un nom qualifié ou ouvrir le module. Si vous utilisez un nom qualifié, vous devez spécifier les espaces de noms, le module et l'identificateur pour l'élément de programme désiré en séparant chaque partie du chemin d'accès qualifié par un point (.), comme suit.
Namespace1.Namespace2.ModuleName.Identifier
Vous pouvez ouvrir le module ou un ou plusieurs des espaces de noms pour simplifier le code. Pour plus d'informations sur l'ouverture d'espaces de noms et de modules, consultez Déclarations d'importation : mot clé open (F#).
L'exemple de code suivant montre un module de niveau supérieur qui contient tout le code jusqu'à la fin du fichier.
module Arithmetic
let add x y =
x + y
let sub x y =
x - y
Pour utiliser ce code à partir d'un autre fichier dans le même projet, vous devez utiliser des noms qualifiés ou ouvrir le module avant d'utiliser les fonctions, comme indiqué dans les exemples suivants.
// Fully qualify the function name.
let result1 = Arithmetic.add 5 9
// Open the module.
open Arithmetic
let result2 = add 5 9
Modules imbriqués
Les modules peuvent être imbriqués. Les modules internes doivent être mis en retrait au niveau des déclarations de module externes, et ce pour indiquer qu'ils constituent des modules internes, et non des nouveaux modules. Par exemple, comparez les deux exemples suivants. Le module Z est un module interne dans le code suivant.
module Y =
let x = 1
module Z =
let z = 5
Mais le module Z est un frère du module Y dans le code suivant.
module Y =
let x = 1
module Z =
let z = 5
Le module Z est également un module frère dans le code suivant, car il n'est pas autant mis en retrait que d'autres déclarations dans le module Y.
module Y =
let x = 1
module Z =
let z = 5
Enfin, si le module externe n'a pas de déclarations et qu'il est suivi immédiatement par une autre déclaration de module, la nouvelle déclaration de module est considérée comme un module interne. Le compilateur vous avertira si la première définition de module n'est pas mise en retrait au-delà de la seconde.
// This code produces a warning, but treats Z as a inner module.
module Y =
module Z =
let z = 5
Pour éliminer l'avertissement, mettez en retrait le module interne.
module Y =
module Z =
let z = 5
Si vous voulez que tout le code dans un fichier se trouve dans un module externe unique et que vous voulez des modules internes, le module externe ne requiert pas le signe égal, et les déclarations, y compris les déclarations de module interne qui iront dans le module externe, n'ont pas besoin d'être mises en retrait. Les déclarations à l'intérieur des déclarations de module interne n'ont pas besoin d'être mises en retrait. Le code suivant illustre ce cas.
// The top-level module declaration can be omitted if the file is named
// TopLevel.fs or topLevel.fs, and the file is the only file in an
// application.
module TopLevel
let topLevelX = 5
module Inner1 =
let inner1X = 1
module Inner2 =
let inner2X = 5