Elixir - Aliases

A fim de facilitar a reutilização de software, Elixir fornece três diretivas - alias, require e import. Ele também fornece uma macro chamada use, resumida a seguir -

# Alias the module so it can be called as Bar instead of Foo.Bar
alias Foo.Bar, as: Bar

# Ensure the module is compiled and available (usually for macros)
require Foo

# Import functions from Foo so they can be called without the `Foo.` prefix
import Foo

# Invokes the custom code defined in Foo as an extension point
use Foo

Vamos agora entender em detalhes sobre cada diretiva.

apelido

A diretiva alias permite que você configure apelidos para qualquer nome de módulo fornecido. Por exemplo, se você deseja fornecer um alias'Str' ao módulo String, você pode simplesmente escrever -

alias String, as: Str
IO.puts(Str.length("Hello"))

O programa acima gera o seguinte resultado -

5

Um alias é dado ao String módulo como Str. Agora, quando chamamos qualquer função usando o literal Str, na verdade faz referência aoStringmódulo. Isso é muito útil quando usamos nomes de módulo muito longos e queremos substituí-los por outros mais curtos no escopo atual.

NOTE - Aliases MUST comece com uma letra maiúscula.

Os aliases são válidos apenas dentro do lexical scope eles são chamados. Por exemplo, se você tiver 2 módulos em um arquivo e fizer um alias dentro de um dos módulos, esse alias não estará acessível no segundo módulo.

Se você der o nome de um módulo embutido, como String ou Tupla, como um alias para algum outro módulo, para acessar o módulo embutido, você precisará precedê-lo com "Elixir.". Por exemplo,

alias List, as: String
#Now when we use String we are actually using List.
#To use the string module: 
IO.puts(Elixir.String.length("Hello"))

Quando o programa acima é executado, ele gera o seguinte resultado -

5

exigir

Elixir fornece macros como um mecanismo para meta-programação (escrever código que gera código).

Macros são pedaços de código que são executados e expandidos no momento da compilação. Isso significa que, para utilizar uma macro, precisamos garantir que seu módulo e implementação estejam disponíveis durante a compilação. Isso é feito com orequire diretiva.

Integer.is_odd(3)

Quando o programa acima for executado, ele gerará o seguinte resultado -

** (CompileError) iex:1: you must require Integer before invoking the macro Integer.is_odd/1

Em Elixir, Integer.is_odd é definido como um macro. Esta macro pode ser usada como um guarda. Isso significa que, a fim de invocarInteger.is_odd, precisaremos do módulo Integer.

Use o require Integer função e execute o programa conforme mostrado abaixo.

require Integer
Integer.is_odd(3)

Desta vez, o programa será executado e produzirá a saída como: true.

Em geral, um módulo não é necessário antes do uso, exceto se quisermos usar as macros disponíveis nesse módulo. Uma tentativa de chamar uma macro que não foi carregada gerará um erro. Observe que, como a diretiva alias, require também tem escopo léxico . Falaremos mais sobre macros em um capítulo posterior.

importar

Nós usamos o importdiretiva para acessar facilmente funções ou macros de outros módulos sem usar o nome totalmente qualificado. Por exemplo, se quisermos usar oduplicate função do módulo List várias vezes, podemos simplesmente importá-la.

import List, only: [duplicate: 2]

Neste caso, estamos importando apenas a função duplicada (com tamanho de lista de argumentos 2) de List. Apesar:only é opcional, seu uso é recomendado para evitar a importação de todas as funções de um determinado módulo dentro do namespace. :except também pode ser fornecido como uma opção para importar tudo em um módulo, exceto uma lista de funções.

o import diretiva também suporta :macros e :functions para ser dado a :only. Por exemplo, para importar todas as macros, um usuário pode escrever -

import Integer, only: :macros

Observe que a importação também é Lexically scopedassim como as diretivas require e alias. Observe também que'import'ing a module also 'require's it.

usar

Embora não seja uma diretiva, use é uma macro intimamente relacionada com requireque permite que você use um módulo no contexto atual. A macro de uso é freqüentemente usada por desenvolvedores para trazer funcionalidade externa para o escopo lexical atual, geralmente módulos. Vamos entender a diretiva de uso por meio de um exemplo -

defmodule Example do 
   use Feature, option: :value 
end

O uso é uma macro que transforma o acima em -

defmodule Example do
   require Feature
   Feature.__using__(option: :value)
end

o use Module primeiro requer o módulo e depois chama o __using__macro no módulo. Elixir tem ótimas capacidades de metaprogramação e macros para gerar código em tempo de compilação. A macro _ _using__ é chamada na instância acima, e o código é injetado em nosso contexto local. O contexto local é onde a macro de uso foi chamada no momento da compilação.