Módulos

Module:
	ModuleDeclaration DeclDefs
DeclDefs
DeclDefs:
	DeclDef
DeclDef DeclDefs
DeclDef:
	AttributeSpecifier
ImportDeclaration
EnumDeclaration
ClassDeclaration
InterfaceDeclaration
AggregateDeclaration
Declaration
Constructor
Destructor
Invariant
UnitTest
StaticConstructor
StaticDestructor
DebugSpecification
VersionSpecification
;

Múdulos tem uma correspondência de um-para-um com arquivos fonte. O nome do módulo é o nome do arquivo com o caminho e extensão retirados.

Módulos provêm automaticamente um escopo de espaço de nomes para seus conteúdos. Múdulos superficialmente lembram classes, mas diferem em:

Há apenas uma instância de cada módulo, e ela é alocada estaticamente.
Não há tabela virtual.
Módulos não herdam, eles não tem supermódulos, etc.
Somente um módulo por arquivo.
Símbolos de módulos podem ser importados.
Módulos são sempre compilados em escopo global, e não são afetados por atributos envolvendo ou outros modificadores.

Módulos podem ser agrupados em hierarquias chamadas pacotes.

Declaração de Módulo

A ModuleDeclaration ajusta o nome do módulo e a que pacote ele pertence. Se ausente, o nome do módulo é tido como sendo o mesmo nome (tirando o caminho e extensão) do nome do arquivo fonte.

ModuleDeclaration:
	module ModuleName ;
ModuleName:
	Identifier
ModuleName . Identifier

O Identifier precedendo o mais a direita são os pacotes em que o módulo está. Os pacotes correspondem aos nomes de diretório no caminho do arquivo fonte.

Se presente, a ModuleDeclaration aparece sintaticamente primeiro no arquivo fonte, e pode haver apenas uma por arquivo fonte.

Exemplo:

module c.stdio; // este é o módilo stdio no pacote c

Por convenção, nomes de pacotes e módulos são todos em letras minúsculas. Isso é porque esses nomes tem uma correspondência de um-para-um com nomes de arquivos e diretórios do sistema operacional, e muitos sisemas de arquivo não são sensíveis ao caso. Todos os nomes de módulos e pacotes em letras minúsculas minimizarão problemas de mover projetos entre sistemas de arquivo diferentes.

Declaração de Importação

Ao inv´s de incluir arquivos de texto, D importa símbolos simbolicamente com a declaração de importação:

ImportDeclaration:
	import ModuleNameList ;
ModuleNameList:
	ModuleName
ModuleName , ModuleNameList

O Identifier mais a direita se torna o nome do módulo. O escopo top level no módulo é fundido com o escopo atual.

Exemplo:

import std.c.stdio; // importa módulo stdio do pacote c
import foo, bar; // importa módulos foo e bar

Escopo e Módulos

Cada módulo forma seu próprio espaço de nomes. Quando um módulo é importado em outro módulo, por padrão todas as declarações dele estão disponíveis sem qualificação. Ambiguities are illegal, and can be resolved by explicitly qualifying the symbol with the module name.

Por exemplo, assuma os seguintes módulos:

// Módulo foo
int x = 1;
int y = 2;

// Módulo bar
int y = 3;
int z = 4;

então:

import foo;
...
q = y; // ajusta q to foo.y

import foo;
int y = 5;
q = y; // y local anula foo.y

import foo;
import bar;
q = y; // erro: foo.y ou bar.y?

import foo;
import bar;
q = bar.y; // q ajustado para 3

Se a importação é privada, tal como:

module abc;
private import def;

então def não é procurado quando outro módulo importa abc.

Operador de Escopo de Módulo

Algumas vezes, é necessário anular as regras de escopamento léxico normais para acessar um nome oculto por um nome local. Isso é feito pelo operador de escopo global, que é um '.':

int x;

int foo(int x)
{
 if (y)
	return x; // retorna foo.x, não x global
 else
return .x; // retorna x global
}

O '.' significa olhar acima no nível de escopo do módulo.

Construção e Destruição Estática

Construtores estáticos são códigos executados para inicializar um módulo ou classe antes da função main() ser chamada. Destruidores estáticos são códigos executados após a função main() retornar, e são normalmente usados para liberar recursos do sistema.

Ordem de Construção Estática

A ordem de inicialização estática é implicitamente determinada pelas declarações import em cada módulo. Cada módulo é assumido para depender de quaisquer módulos importados sendo estaticamente construidos primeiro. A exceção de seguir essa regra, não há ordem imposta de executar construtores de módulo estáticos.

Ciclos (dependências circulares) em declarações de importação são contanto que ambos os módulos não contenham construtores estáticos ou destrutores estáticos. Violação dessa regra resultará em uma exceção em tempo de execução.

Ordem de Contrução Estática dentro de um Módulo

Dentro de um módulo, a construção estática ocorre na ordem léxica que eles aparecem.

Ordem de Destruição Estática

É definida para ser exatamente a ordem inversa em que a construção estática foi feita. Destrutores estáticos para módulos individuais somente serão executados se o construtor estático correspondente for completado com sucesso.

Ordem de Testes de Unidade

Testes de unidade são executados na ordem léxica em que aparecem no módulo.