Erlang - Fonctions

Erlang est connu comme un langage de programmation fonctionnel, par conséquent vous vous attendez à voir beaucoup d'emphase sur le fonctionnement des fonctions dans Erlang. Ce chapitre couvre tout ce qui peut être fait avec les fonctions d'Erlang.

Définition d'une fonction

La syntaxe d'une déclaration de fonction est la suivante -

Syntaxe

FunctionName(Pattern1… PatternN) ->
Body;

Où,

  • FunctionName - Le nom de la fonction est un atome.

  • Pattern1… PatternN- Chaque argument est un modèle. Le nombre d'arguments N est l'arité de la fonction. Une fonction est définie de manière unique par le nom du module, le nom de la fonction et l'arité. Autrement dit, deux fonctions avec le même nom et dans le même module, mais avec des arités différentes sont deux fonctions différentes.

  • Body - Un corps de clause se compose d'une séquence d'expressions séparées par des virgules (,):

Le programme suivant est un exemple simple d'utilisation de fonctions -

Exemple

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

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

Les pointeurs suivants doivent être notés sur le programme ci-dessus -

  • Nous définissons deux fonctions, l'une s'appelle add qui prend 2 paramètres et l'autre est le start fonction.

  • Les deux fonctions sont définies avec la fonction d'exportation. Si nous ne le faisons pas, nous ne pourrons pas utiliser la fonction.

  • Une fonction peut être appelée dans une autre. Ici, nous appelons la fonction add à partir de la fonction de démarrage.

La sortie du programme ci-dessus sera -

Production

11

Fonctions anonymes

Une fonction anonyme est une fonction à laquelle aucun nom n'est associé. Erlang a la possibilité de définir des fonctions anonymes. Le programme suivant est un exemple de fonction anonyme.

Exemple

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

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

Les points suivants doivent être notés à propos de l'exemple ci-dessus -

  • La fonction anonyme est définie avec le fun() mot-clé.

  • La fonction est affectée à une variable appelée Fn.

  • La fonction est appelée via le nom de la variable.

La sortie du programme ci-dessus sera -

Production

Anonymous Function

Fonctions avec plusieurs arguments

Les fonctions Erlang peuvent être définies avec zéro ou plusieurs paramètres. La surcharge de fonctions est également possible, dans laquelle vous pouvez définir une fonction avec le même nom plusieurs fois, à condition qu'elles aient un nombre différent de paramètres.

Dans l'exemple suivant, la démo de fonction est définie avec plusieurs arguments pour chaque définition de fonction.

Exemple

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

Dans le programme ci-dessus, nous définissons la fonction add deux fois. Mais la définition de la première fonction d'ajout prend deux paramètres et la seconde prend trois paramètres.

La sortie du programme ci-dessus sera -

Production

11
17

Fonctions avec séquences de garde

Les fonctions d'Erlang ont également la capacité d'avoir des séquences de garde. Ce ne sont que des expressions qui, lorsqu'elles sont évaluées à true, entraîneront l'exécution de la fonction.

La syntaxe d'une fonction avec une séquence de garde est indiquée dans le programme suivant.

Syntaxe

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

Où,

  • FunctionName - Le nom de la fonction est un atome.

  • Pattern1… PatternN- Chaque argument est un modèle. Le nombre d'arguments N est l'arité de la fonction. Une fonction est définie de manière unique par le nom du module, le nom de la fonction et l'arité. Autrement dit, deux fonctions avec le même nom et dans le même module, mais avec des arités différentes sont deux fonctions différentes.

  • Body - Un corps de clause se compose d'une séquence d'expressions séparées par une virgule (,).

  • GuardSeq1 - C'est l'expression qui est évaluée lorsque la fonction est appelée.

Le programme suivant est un exemple simple d'utilisation d'une fonction avec une séquence de garde.

Exemple

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

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

start() -> 
   add(4).

La sortie du programme ci-dessus est -

Production

4

Si la fonction d'ajout a été appelée comme add(3), le programme provoquera une erreur.