Erlang - Funzioni

Erlang è noto come linguaggio di programmazione funzionale, quindi ti aspetteresti di vedere molta enfasi su come funzionano le funzioni in Erlang. Questo capitolo descrive cosa si può fare con le funzioni di Erlang.

Definizione di una funzione

La sintassi di una dichiarazione di funzione è la seguente:

Sintassi

FunctionName(Pattern1… PatternN) ->
Body;

Dove,

• FunctionName - Il nome della funzione è un atomo.

• Pattern1… PatternN- Ogni argomento è uno schema. Il numero di argomenti N è l'arità della funzione. Una funzione è definita in modo univoco dal nome del modulo, dal nome della funzione e dall'arità. Cioè, due funzioni con lo stesso nome e nello stesso modulo, ma con arità differenti sono due funzioni differenti.

• Body - Il corpo di una clausola è costituito da una sequenza di espressioni separate da virgola (,):

Il seguente programma è un semplice esempio dell'uso delle funzioni:

Esempio

-module(helloworld). 
-export([add/2,start/0]). 

add(X,Y) -> 
   Z = X+Y, 
   io:fwrite("~w~n",[Z]). 
   
start() -> 
   add(5,6).

I seguenti suggerimenti dovrebbero essere annotati sul programma di cui sopra:

• Stiamo definendo due funzioni, una è chiamata add che accetta 2 parametri e l'altro è il file start funzione.

• Entrambe le funzioni sono definite con la funzione di esportazione. Se non lo facciamo, non saremo in grado di utilizzare la funzione.

• Una funzione può essere chiamata all'interno di un'altra. Qui stiamo chiamando la funzione di aggiunta dalla funzione di avvio.

L'output del programma di cui sopra sarà:

Produzione

11

Funzioni anonime

Una funzione anonima è una funzione a cui non è associato alcun nome. Erlang ha la possibilità di definire funzioni anonime. Il seguente programma è un esempio di una funzione anonima.

Esempio

-module(helloworld). 
-export([start/0]). 

start() -> 
   Fn = fun() -> 
      io:fwrite("Anonymous Function") end, 
   Fn().

I seguenti punti devono essere annotati sull'esempio sopra:

• La funzione anonima è definita con il fun() parola chiave.

• La funzione è assegnata a una variabile chiamata Fn.

• La funzione viene chiamata tramite il nome della variabile.

L'output del programma di cui sopra sarà:

Produzione

Anonymous Function

Funzioni con più argomenti

Le funzioni Erlang possono essere definite con zero o più parametri. È anche possibile il sovraccarico di funzioni, in cui è possibile definire più volte una funzione con lo stesso nome, purché abbia un numero di parametri diverso.

Nell'esempio seguente, la demo della funzione è definita con più argomenti per ciascuna definizione di funzione.

Esempio

-module(helloworld). 
-export([add/2,add/3,start/0]). 

add(X,Y) -> 
   Z = X+Y, 
   io:fwrite("~w~n",[Z]). 
   
add(X,Y,Z) -> 
   A = X+Y+Z, 
   io:fwrite("~w~n",[A]). 
 
start() ->
   add(5,6), 
   add(5,6,6).

Nel programma sopra, stiamo definendo la funzione di aggiunta due volte. Ma la definizione della prima funzione di aggiunta richiede due parametri e la seconda accetta tre parametri.

L'output del programma di cui sopra sarà:

Produzione

11
17

Funziona con sequenze di guardia

Le funzioni in Erlang hanno anche la capacità di avere sequenze di guardia. Queste non sono altro che espressioni che solo se valutate su true causeranno l'esecuzione della funzione.

La sintassi di una funzione con una sequenza di guardia è mostrata nel programma seguente.

Sintassi

FunctionName(Pattern1… PatternN) [when GuardSeq1]->
Body;

Dove,

• FunctionName - Il nome della funzione è un atomo.

• Pattern1… PatternN- Ogni argomento è uno schema. Il numero di argomenti N è l'arità della funzione. Una funzione è definita in modo univoco dal nome del modulo, dal nome della funzione e dall'arità. Cioè, due funzioni con lo stesso nome e nello stesso modulo, ma con arità differenti sono due funzioni differenti.

• Body - Il corpo di una clausola è costituito da una sequenza di espressioni separate da una virgola (,).

• GuardSeq1 - Questa è l'espressione che viene valutata quando viene chiamata la funzione.

Il seguente programma è un semplice esempio dell'uso di una funzione con una sequenza di guardia.

Esempio

-module(helloworld). 
-export([add/1,start/0]). 

add(X) when X>3 -> 
   io:fwrite("~w~n",[X]). 

start() -> 
   add(4).

L'output del programma di cui sopra è:

Produzione

4

Se la funzione di aggiunta è stata chiamata come add(3), il programma genererà un errore.