Elixir - Alias

Para facilitar la reutilización del software, Elixir proporciona tres directivas: alias, require y import. También proporciona una macro llamada uso que se resume a continuación:

# 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

Entendamos ahora en detalle sobre cada directiva.

alias

La directiva de alias le permite configurar alias para cualquier nombre de módulo dado. Por ejemplo, si quiere dar un alias'Str' al módulo String, simplemente puede escribir -

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

El programa anterior genera el siguiente resultado:

Se le da un alias al String módulo como Str. Ahora, cuando llamamos a cualquier función usando el literal Str, en realidad hace referencia alStringmódulo. Esto es muy útil cuando usamos nombres de módulos muy largos y queremos sustituirlos por otros más cortos en el ámbito actual.

NOTE - Alias MUST comience con una letra mayúscula.

Los alias son válidos solo dentro del lexical scope se llaman. Por ejemplo, si tiene 2 módulos en un archivo y crea un alias dentro de uno de los módulos, ese alias no será accesible en el segundo módulo.

Si da el nombre de un módulo incorporado, como String o Tuple, como alias de algún otro módulo, para acceder al módulo incorporado, deberá anteponerlo con "Elixir.". Por ejemplo,

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"))

Cuando se ejecuta el programa anterior, genera el siguiente resultado:

exigir

Elixir proporciona macros como mecanismo de metaprogramación (escribir código que genera código).

Las macros son fragmentos de código que se ejecutan y expanden en el momento de la compilación. Esto significa que, para utilizar una macro, debemos garantizar que su módulo y su implementación estén disponibles durante la compilación. Esto se hace con elrequire directiva.

Integer.is_odd(3)

Cuando se ejecuta el programa anterior, generará el siguiente resultado:

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

En Elixir, Integer.is_odd se define como un macro. Esta macro se puede utilizar como protección. Esto significa que, para invocarInteger.is_odd, necesitaremos el módulo Integer.

Utilizar el require Integer función y ejecute el programa como se muestra a continuación.

require Integer
Integer.is_odd(3)

Esta vez, el programa se ejecutará y producirá la salida como: true.

En general, no se requiere un módulo antes de su uso, excepto si queremos usar las macros disponibles en ese módulo. Un intento de llamar a una macro que no se cargó generará un error. Tenga en cuenta que, al igual que la directiva de alias, require también tiene un ámbito léxico . Hablaremos más sobre macros en un capítulo posterior.

importar

Usamos el importdirectiva para acceder fácilmente a funciones o macros de otros módulos sin utilizar el nombre completo. Por ejemplo, si queremos usar elduplicate función del módulo List varias veces, simplemente podemos importarlo.

import List, only: [duplicate: 2]

En este caso, estamos importando solo la función duplicada (con una longitud de lista de argumentos 2) de List. A pesar de que:only es opcional, se recomienda su uso para evitar importar todas las funciones de un módulo dado dentro del espacio de nombres. :except también se podría dar como una opción para importar todo en un módulo excepto una lista de funciones.

los import la directiva también apoya :macros y :functions para ser dado a :only. Por ejemplo, para importar todas las macros, un usuario puede escribir:

import Integer, only: :macros

Tenga en cuenta que la importación también es Lexically scopedal igual que las directivas require y alias. También tenga en cuenta que'import'ing a module also 'require's it.

utilizar

Aunque no es una directiva, use es una macro estrechamente relacionada con requireque le permite utilizar un módulo en el contexto actual. Los desarrolladores utilizan con frecuencia la macro de uso para incorporar funciones externas al ámbito léxico actual, a menudo módulos. Entendamos la directiva de uso a través de un ejemplo:

defmodule Example do 
   use Feature, option: :value 
end

El uso es una macro que transforma lo anterior en:

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

los use Module primero requiere el módulo y luego llama al __using__macro en el módulo. Elixir tiene grandes capacidades de metaprogramación y tiene macros para generar código en tiempo de compilación. La macro _ _using__ se llama en la instancia anterior y el código se inyecta en nuestro contexto local. El contexto local es donde se llamó a la macro de uso en el momento de la compilación.