Elisir - Alias

Per facilitare il riutilizzo del software, Elixir fornisce tre direttive: alias, require e import. Fornisce anche una macro chiamata use che è riassunta di seguito:

# 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

Vediamo ora di comprendere in dettaglio ciascuna direttiva.

alias

La direttiva alias consente di impostare alias per qualsiasi nome di modulo dato. Ad esempio, se vuoi fornire un alias'Str' al modulo String, puoi semplicemente scrivere -

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

Il programma di cui sopra genera il seguente risultato:

5

Viene assegnato un alias a String modulo come Str. Ora, quando chiamiamo una funzione usando il letterale Str, in realtà fa riferimento aStringmodulo. Questo è molto utile quando usiamo nomi di moduli molto lunghi e vogliamo sostituire quelli con quelli più brevi nell'ambito corrente.

NOTE - Alias MUST inizia con una lettera maiuscola.

Gli alias sono validi solo all'interno di lexical scope vengono chiamati. Ad esempio, se si hanno 2 moduli in un file e si crea un alias all'interno di uno dei moduli, tale alias non sarà accessibile nel secondo modulo.

Se dai il nome di un modulo integrato, come String o Tuple, come alias a qualche altro modulo, per accedere al modulo integrato, dovrai anteporlo con "Elixir.". Per esempio,

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 il programma precedente viene eseguito, genera il seguente risultato:

5

richiedono

Elixir fornisce le macro come meccanismo per la meta-programmazione (scrittura di codice che genera codice).

Le macro sono blocchi di codice che vengono eseguiti ed espansi al momento della compilazione. Ciò significa che, per poter utilizzare una macro, dobbiamo garantire che il suo modulo e la sua implementazione siano disponibili durante la compilazione. Questo viene fatto con ilrequire direttiva.

Integer.is_odd(3)

Quando il programma di cui sopra viene eseguito, genererà il seguente risultato:

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

In Elisir, Integer.is_odd è definito come un macro. Questa macro può essere utilizzata come guardia. Ciò significa che, al fine di invocareInteger.is_odd, avremo bisogno del modulo Integer.

Utilizzare il require Integer funzione ed eseguire il programma come mostrato di seguito.

require Integer
Integer.is_odd(3)

Questa volta il programma verrà eseguito e produrrà l'output come: true.

In generale, un modulo non è richiesto prima dell'uso, tranne se si desidera utilizzare le macro disponibili in quel modulo. Un tentativo di chiamare una macro che non è stata caricata genererà un errore. Si noti che, come la direttiva alias, anche require ha un ambito lessicale . Parleremo di più delle macro in un capitolo successivo.

importare

Noi usiamo il importdirettiva per accedere facilmente a funzioni o macro da altri moduli senza utilizzare il nome completo. Ad esempio, se vogliamo utilizzare l'estensioneduplicate più volte dal modulo List, possiamo semplicemente importarla.

import List, only: [duplicate: 2]

In questo caso, stiamo importando solo la funzione duplicate (con lunghezza dell'elenco di argomenti 2) da List. Sebbene:only è opzionale, il suo utilizzo è consigliato per evitare di importare tutte le funzioni di un dato modulo all'interno del namespace. :except potrebbe anche essere fornito come opzione per importare tutto in un modulo tranne un elenco di funzioni.

Il import la direttiva supporta anche :macros e :functions da dare a :only. Ad esempio, per importare tutte le macro, un utente può scrivere:

import Integer, only: :macros

Nota che anche l'importazione lo è Lexically scopedproprio come le direttive require e alias. Nota anche quello'import'ing a module also 'require's it.

uso

Sebbene non sia una direttiva, use è una macro strettamente correlata a requireche ti consente di utilizzare un modulo nel contesto corrente. La macro di utilizzo è spesso utilizzata dagli sviluppatori per portare funzionalità esterne nell'attuale ambito lessicale, spesso moduli. Cerchiamo di capire la direttiva sull'uso attraverso un esempio:

defmodule Example do 
   use Feature, option: :value 
end

Use è una macro che trasforma quanto sopra in -

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

Il use Module richiede prima il modulo e quindi chiama il file __using__macro sul modulo. Elixir ha grandi capacità di metaprogrammazione e ha macro per generare codice in fase di compilazione. La macro _ _using__ viene chiamata nell'istanza precedente e il codice viene inserito nel nostro contesto locale. Il contesto locale è quello in cui è stata chiamata la macro di utilizzo al momento della compilazione.