Módulos (F#)
No contexto da linguagem F#, um módulo de é um agrupamento de F# código, como, por exemplo, valores, tipos e valores de função, em um programa F#. Agrupar os códigos em módulos ajuda a manter o código relacionado e ajuda a evitar conflitos de nome no seu programa.
// Top-level module declaration.
module [accessibility-modifier] [qualified-namespace.]module-name
declarations
// Local module declaration.
module [accessibility-modifier] module-name =
declarations
Comentários
Um módulo do F# é um agrupamento de construções de código F# como, por exemplo, tipos, valores, valores de função e código em do ligações. Ele é implementado como uma classe de runtime (CLR) de idioma comum que tenha apenas membros estáticos. Há dois tipos de declarações do módulo, dependendo se o arquivo inteiro está incluído no módulo: uma declaração do módulo de nível superior e uma declaração de local do módulo. Uma declaração de nível superior do módulo inclui o arquivo inteiro no módulo. Uma declaração de nível superior do módulo pode aparecer somente como a primeira declaração em um arquivo.
Na sintaxe da declaração de nível superior do módulo opcional qualified-namespace é a seqüência de nomes do namespace aninhado que contém o módulo. O espaço para nome qualificado não precisa ser declarada anteriormente.
Você não tem que recuar as declarações em um módulo de nível superior. É necessário recuar todas as declarações de módulos de locais. Em uma declaração do módulo local, somente as declarações são recuadas sob a declaração do módulo são parte do módulo.
Se um arquivo de código não começa com uma declaração de nível superior do módulo ou uma declaração de namespace, todo o conteúdo do arquivo, incluindo os módulos de qualquer locais, torna-se parte de um módulo de nível superior criado implicitamente que tem o mesmo nome do arquivo, sem a extensão, com a primeira letra convertida em maiúsculas. Por exemplo, considere o seguinte arquivo.
// In the file program.fs.
let x = 40
Este arquivo deve ser compilado como se tivesse sido feita dessa maneira:
module Program
let x = 40
Se você tiver vários módulos em um arquivo, você deve usar uma declaração do módulo de local para cada módulo. Se o namespace de encerramento é declarado, esses módulos são parte do namespace de encerramento. Se não está declarado como um namespace de encerramento, os módulos tornam-se parte do módulo de nível superior criado implicitamente. O exemplo de código a seguir mostra um arquivo de código que contém vários módulos. O compilador cria implicitamente um módulo de nível superior chamado Multiplemodules, e MyModule1 e MyModule2 estão aninhadas nesse módulo de nível 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)
Se você tiver vários arquivos em um projeto ou em uma única compilação, ou se você estiver criando uma biblioteca, você deve incluir uma declaração de namespace ou uma declaração de módulo na parte superior do arquivo. O compilador F# determina apenas o nome do módulo em implicitamente quando há apenas um arquivo em uma linha de comando de compilação ou de projeto e criação de um aplicativo.
O accessibility-modifier pode ser uma das seguintes opções: public, private, internal. Para obter mais informações, consulte Controle de acesso (F#). O padrão é público.
Referência ao código em módulos
Ao fazer referência a funções, tipos e valores de outro módulo, você deve usar um nome qualificado ou abrir o módulo. Se você usar um nome qualificado, você deve especificar os namespaces, o módulo e o identificador para o elemento de programa desejado. Separar cada parte do caminho qualificado com um ponto (.), como se segue.
Namespace1.Namespace2.ModuleName.Identifier
Você pode abrir o módulo ou de um ou mais dos namespaces para simplificar o código. Para obter mais informações sobre namespaces de abertura e de módulos, consulte Declarações de importação: A palavra-chave aberta (F#).
O exemplo de código a seguir mostra um módulo de nível superior que contém todo o código até o final do arquivo.
module Arithmetic
let add x y =
x + y
let sub x y =
x - y
Para usar esse código de outro arquivo no mesmo projeto, você usa nomes qualificados ou abrir o módulo antes de usar as funções, como mostrado nos exemplos a seguir.
// Fully qualify the function name.
let result1 = Arithmetic.add 5 9
// Open the module.
open Arithmetic
let result2 = add 5 9
Módulos aninhados
Módulos podem ser aninhados. Módulos internos devem ser recuados quanto de declarações do módulo externo para indicar que são módulos internos, não de novos módulos. Por exemplo, compare os dois exemplos a seguir. Módulo Z é um módulo interno, o código a seguir.
module Y =
let x = 1
module Z =
let z = 5
Mas o módulo Z é um irmão do módulo de Y o código a seguir.
module Y =
let x = 1
module Z =
let z = 5
Módulo Z é também um módulo de irmãos no código a seguir, pois é recuado não diz respeito a outras declarações no módulo Y.
module Y =
let x = 1
module Z =
let z = 5
Finalmente, se o módulo externo não tem nenhum declarações e é seguido imediatamente por outra declaração de módulo, a nova declaração de módulo será considerada um módulo interno, mas o compilador irá avisá-lo se a segunda definição de módulo não é recuada mais longe do que o primeiro.
// This code produces a warning, but treats Z as a inner module.
module Y =
module Z =
let z = 5
Para eliminar o aviso, o recuo do módulo interno.
module Y =
module Z =
let z = 5
Se você deseja que todo o código em um arquivo em um único módulo externo e você desejar que o módulos internos, o módulo externo não exige o sinal de igual e declarações, incluindo qualquer declaração do módulo interno, que irá no módulo externo não precisam ser recuado. Declarações dentro de declarações de módulo interno têm será recuado. O código a seguir mostra esse 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