Módulos (F#)
En el contexto del lenguaje F#, un módulo es una agrupación de código de F#, como valores, tipos y valores de función, en un programa de F#. Agrupar el código en módulos ayuda a mantener junto el código relacionado y a evitar conflictos de nombres en los programas.
// Top-level module declaration.
module [accessibility-modifier] [qualified-namespace.]module-name
declarations
// Local module declaration.
module [accessibility-modifier] module-name =
declarations
Comentarios
Un módulo de F# es una agrupación de construcciones de código de F#, tales como tipos, valores, valores de función y código en enlaces do. Se implementa como una clase de Common Language Runtime (CLR) que únicamente tiene miembros estáticos. Hay dos tipos de declaraciones de módulo, dependiendo de si se incluye en el módulo el archivo completo o no: la declaración de módulo de nivel superior y la declaración de módulo local. Una declaración de módulo de nivel superior incluye el archivo completo en el módulo. Este tipo de declaración únicamente puede aparecer como la primera declaración de un archivo.
En la sintaxis de la declaración de módulo de nivel superior, el parámetro qualified-namespace opcional es la secuencia de nombres de espacios de nombres anidados que contiene el módulo. No es necesario declarar previamente el espacio de nombres calificado.
No es preciso aplicar sangría a las declaraciones en un módulo de nivel superior. Sí es necesario aplicar sangría a todas las declaraciones en los módulos locales. En una declaración de módulo local, únicamente forman parte del módulo las declaraciones con sangría por debajo de su declaración.
Si un archivo de código no comienza con una declaración de módulo de nivel superior o una declaración de espacio de nombres, el contenido completo del archivo, incluidos todos los módulos locales, pasan a formar parte de un módulo de nivel superior creado implícitamente que tiene el mismo nombre que el archivo, sin la extensión, con la primera letra en mayúscula. Por ejemplo, fíjese en el archivo siguiente.
// In the file program.fs.
let x = 40
Este archivo se compilaría como si estuviera escrito como sigue:
module Program
let x = 40
Si hay varios módulos en un archivo, se debe utilizar una declaración de módulo local para cada uno de ellos. Si se declara un espacio de nombres contenedor, estos módulos forman parte de él. Si no se declara un espacio de nombres contenedor, los módulos pasan a formar parte del módulo de nivel superior creado implícitamente. En el ejemplo de código siguiente se muestra un archivo de código que contiene varios módulos. El compilador crea implícitamente un módulo de nivel superior denominado Multiplemodules; MyModule1 y MyModule2 están anidados en ese módulo de nivel superior.
// 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 tiene varios archivos en un proyecto o en una sola compilación o si va a compilar una biblioteca, deberá incluir una declaración de espacio de nombres o una declaración de módulo al principio del archivo. El compilador de F# determina implícitamente un nombre de módulo cuando solo hay un archivo en un proyecto o en la línea de comandos de compilación y se está creando una aplicación.
accessibility-modifier puede ser uno de los siguientes: public, private o internal. Para obtener más información, vea Control de acceso (F#). El valor predeterminado es que sea pública.
Hacer referencia al código en los módulos
Cuando se hace referencia a funciones, tipos y valores desde otro módulo, se debe utilizar un nombre calificado o abrir el módulo. Si se utiliza un nombre calificado, hay que especificar los espacios de nombres, el módulo y el identificador para el elemento de programa correspondiente. Las partes de la ruta de acceso calificada se separan entre sí con un punto (.), como sigue.
Namespace1.Namespace2.ModuleName.Identifier
Se puede abrir el módulo o uno o varios espacios de nombres a fin de simplificar el código. Para obtener más información acerca de cómo abrir espacios de nombres y módulos, vea Declaraciones de importación: la palabra clave open (F#).
En el ejemplo de código siguiente se muestra un módulo de nivel superior que contiene todo el código hasta el final del archivo.
module Arithmetic
let add x y =
x + y
let sub x y =
x - y
Para utilizar este código desde otro archivo del mismo proyecto, puede usar nombres calificados o bien abrir el módulo antes de utilizar las funciones, como se muestra en los ejemplos siguientes.
// Fully qualify the function name.
let result1 = Arithmetic.add 5 9
// Open the module.
open Arithmetic
let result2 = add 5 9
Módulos anidados
Los módulos se pueden anidar. A los módulos internos se les debe aplicar tanta sangría como a las declaraciones de módulo exteriores, a fin de indicar que se trata de módulos internos y no de nuevos módulos. Por ejemplo, compare los dos ejemplos los siguientes. El módulo Z es un módulo interno en el código siguiente.
module Y =
let x = 1
module Z =
let z = 5
Sin embargo, el módulo Z es un elemento relacionado del módulo Y en el código siguiente.
module Y =
let x = 1
module Z =
let z = 5
El módulo Z también es un módulo relacionado en el código siguiente, porque tiene menos sangría que las demás declaraciones del módulo Y.
module Y =
let x = 1
module Z =
let z = 5
Por último, si el módulo exterior no tiene ninguna declaración y va seguido inmediatamente por otra declaración de módulo, se da por hecho que la nueva declaración de módulo es un módulo interno, pero el compilador mostrará una advertencia si la segunda definición de módulo no tiene más sangría que la primera.
// This code produces a warning, but treats Z as a inner module.
module Y =
module Z =
let z = 5
Para eliminar la advertencia, debe aplicarse sangría al módulo interno.
module Y =
module Z =
let z = 5
Si se desea que todo el código de un archivo esté en un módulo exterior único y se desea que haya módulos internos, el módulo exterior no requiere el signo igual; tampoco es necesario aplicar sangría a las declaraciones que vayan a ir en el módulo externo, aunque sean declaraciones de módulo interno. A las declaraciones que van dentro de las declaraciones de módulo interno sí se les tiene que aplicar sangría. En el ejemplo de código siguiente se muestra este caso.
// 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