Erlang - Módulos
Módulos são um conjunto de funções reagrupadas em um único arquivo, sob um único nome. Além disso, todas as funções em Erlang devem ser definidas em módulos.
A maioria das funcionalidades básicas como operadores aritméticos, lógicos e booleanos já estão disponíveis porque os módulos padrão são carregados quando um programa é executado. Todas as outras funções definidas em um módulo que você usará precisam ser chamadas com o formulárioModule:Function (Argumentos).
Definindo um Módulo
Com um módulo, você pode declarar dois tipos de coisas: funções e atributos. Atributos são metadados que descrevem o próprio módulo, como seu nome, as funções que devem ser visíveis para o mundo externo, o autor do código e assim por diante. Esse tipo de metadados é útil porque dá dicas ao compilador sobre como ele deve fazer seu trabalho e também porque permite que as pessoas recuperem informações úteis do código compilado sem ter que consultar o código-fonte.
A sintaxe de uma declaração de função é a seguinte -
Sintaxe
-module(modulename)
Onde, modulenameé o nome do módulo. Essa deve ser a primeira linha do código no módulo.
O programa a seguir mostra um exemplo de um módulo chamado helloworld.
Exemplo
-module(helloworld).
-export([start/0]).
start() ->
io:fwrite("Hello World").
O resultado do programa acima é -
Resultado
Hello World
Atributos do Módulo
Um atributo de módulo define uma determinada propriedade de um módulo. Um atributo de módulo consiste em uma tag e um valor.
A sintaxe geral de um atributo é -
Sintaxe
-Tag(Value)
Um exemplo de como o atributo pode ser usado é mostrado no programa a seguir -
Exemplo
-module(helloworld).
-author("TutorialPoint").
-version("1.0").
-export([start/0]).
start() ->
io:fwrite("Hello World").
O programa acima define 2 atributos personalizados chamados autor e versão, que contém o autor do programa e o número da versão do programa, respectivamente.
O resultado do programa acima é -
Resultado
Hello World
Atributos pré-construídos
Erlang possui alguns atributos pré-construídos que podem ser anexados aos módulos. Vamos dar uma olhada neles.
Exportar
O atributo de exportação pegará uma lista de funções e aridade para exportar para consumo por outros módulos. Ele definirá a interface do módulo. Já vimos isso em todos os nossos exemplos anteriores.
Sintaxe
export([FunctionName1/FunctionArity1,.,FunctionNameN/FunctionArityN])
Onde,
FunctionName - Este é o nome da função no programa.
FunctionArity - Este é o número de parâmetros associados à função.
Exemplo
-module(helloworld).
-author("TutorialPoint").
-version("1.0").
-export([start/0]).
start() ->
io:fwrite("Hello World").
O resultado do programa acima será -
Resultado
Hello World
Importar
O atributo import é usado para importar funções de outro módulo para usá-lo como local.
Sintaxe
-import (modulename , [functionname/parameter]).
Onde,
Modulename - Este é o nome do módulo que precisa ser importado.
functionname/parameter - a função no módulo que precisa ser importada.
Exemplo
-module(helloworld).
-import(io,[fwrite/1]).
-export([start/0]).
start() ->
fwrite("Hello, world!\n").
No código acima, estamos usando a palavra-chave import para importar a biblioteca 'io' e, especificamente, a função fwrite. Portanto, agora, sempre que invocarmos a função fwrite, não precisamos mencionar o nome do módulo io em todos os lugares.
O resultado do programa acima será -
Resultado
Hello, world!